code stringlengths 31 2.05k | label_name stringclasses 5 values | label int64 0 4 |
|---|---|---|
static pj_status_t dtls_create(transport_srtp *srtp,
pjmedia_transport **p_keying)
{
dtls_srtp *ds;
pj_pool_t *pool;
pj_status_t status;
pool = pj_pool_create(srtp->pool->factory, "dtls%p",
2000, 256, NULL);
ds = PJ_POOL_ZALLOC_T(pool, dtls_srtp);
ds->pool = pool;
pj_ansi_strxcpy(ds->base.name, pool->obj_name, PJ_MAX_OBJ_NAME);
ds->base.type = (pjmedia_transport_type)PJMEDIA_SRTP_KEYING_DTLS_SRTP;
ds->base.op = &dtls_op;
ds->base.user_data = srtp;
ds->srtp = srtp;
status = pj_lock_create_simple_mutex(ds->pool, "dtls_ssl_lock%p",
&ds->ossl_lock);
if (status != PJ_SUCCESS)
return status;
*p_keying = &ds->base;
PJ_LOG(5,(srtp->pool->obj_name, "SRTP keying DTLS-SRTP created"));
return PJ_SUCCESS;
} | Variant | 0 |
static pj_status_t ssl_match_fingerprint(dtls_srtp *ds, unsigned idx)
{
X509 *rem_cert;
pj_bool_t is_sha256;
char buf[128];
pj_size_t buf_len = sizeof(buf);
pj_status_t status;
/* Check hash algo, currently we only support SHA-256 & SHA-1 */
if (!pj_strnicmp2(&ds->rem_fingerprint, "SHA-256 ", 8))
is_sha256 = PJ_TRUE;
else if (!pj_strnicmp2(&ds->rem_fingerprint, "SHA-1 ", 6))
is_sha256 = PJ_FALSE;
else {
PJ_LOG(4,(ds->base.name, "Hash algo specified in remote SDP for "
"its DTLS certificate fingerprint is not supported"));
return PJ_ENOTSUP;
}
pj_lock_acquire(ds->ossl_lock);
if (!ds->ossl_ssl[idx]) {
pj_lock_release(ds->ossl_lock);
return PJ_EGONE;
}
/* Get remote cert & calculate the hash */
rem_cert = SSL_get_peer_certificate(ds->ossl_ssl[idx]);
pj_lock_release(ds->ossl_lock);
if (!rem_cert)
return PJMEDIA_SRTP_DTLS_EPEERNOCERT;
status = ssl_get_fingerprint(rem_cert, is_sha256, buf, &buf_len);
X509_free(rem_cert);
if (status != PJ_SUCCESS)
return status;
/* Do they match? */
if (pj_stricmp2(&ds->rem_fingerprint, buf))
return PJMEDIA_SRTP_DTLS_EFPNOTMATCH;
return PJ_SUCCESS;
} | Variant | 0 |
static pj_status_t ssl_on_recv_packet(dtls_srtp *ds, unsigned idx,
const void *data, pj_size_t len)
{
char tmp[128];
pj_size_t nwritten;
pj_lock_acquire(ds->ossl_lock);
if (!ds->ossl_rbio[idx]) {
pj_lock_release(ds->ossl_lock);
return PJ_EGONE;
}
nwritten = BIO_write(ds->ossl_rbio[idx], data, (int)len);
if (nwritten < len) {
/* Error? */
pj_status_t status;
status = GET_SSL_STATUS(ds);
#if DTLS_DEBUG
pj_perror(2, ds->base.name, status, "BIO_write() error");
#endif
pj_lock_release(ds->ossl_lock);
return status;
}
if (!ds->ossl_ssl[idx]) {
pj_lock_release(ds->ossl_lock);
return PJ_EGONE;
}
/* Consume (and ignore) the packet */
while (1) {
int rc = SSL_read(ds->ossl_ssl[idx], tmp, sizeof(tmp));
if (rc <= 0) {
#if DTLS_DEBUG
pj_status_t status = GET_SSL_STATUS(ds);
if (status != PJ_SUCCESS)
pj_perror(2, ds->base.name, status, "SSL_read() error");
#endif
break;
}
}
pj_lock_release(ds->ossl_lock);
/* Flush anything pending in the write BIO */
return ssl_flush_wbio(ds, idx);
} | Variant | 0 |
static pj_status_t dtls_destroy(pjmedia_transport *tp)
{
dtls_srtp *ds = (dtls_srtp *)tp;
#if DTLS_DEBUG
PJ_LOG(2,(ds->base.name, "dtls_destroy()"));
#endif
dtls_destroy_channel(ds, RTP_CHANNEL);
dtls_destroy_channel(ds, RTCP_CHANNEL);
if (ds->ossl_lock) {
pj_lock_destroy(ds->ossl_lock);
ds->ossl_lock = NULL;
}
pj_pool_safe_release(&ds->pool);
return PJ_SUCCESS;
} | Variant | 0 |
static void ssl_destroy(dtls_srtp *ds, unsigned idx)
{
pj_lock_acquire(ds->ossl_lock);
/* Destroy SSL instance */
if (ds->ossl_ssl[idx]) {
/**
* Avoid calling SSL_shutdown() if handshake wasn't completed.
* OpenSSL 1.0.2f complains if SSL_shutdown() is called during an
* SSL handshake, while previous versions always return 0.
*/
if (SSL_in_init(ds->ossl_ssl[idx]) == 0) {
SSL_shutdown(ds->ossl_ssl[idx]);
}
SSL_free(ds->ossl_ssl[idx]); /* this will also close BIOs */
ds->ossl_ssl[idx] = NULL;
/* thus reset the BIOs as well */
ds->ossl_rbio[idx] = NULL;
ds->ossl_wbio[idx] = NULL;
}
/* Destroy SSL context */
if (ds->ossl_ctx[idx]) {
SSL_CTX_free(ds->ossl_ctx[idx]);
ds->ossl_ctx[idx] = NULL;
}
pj_lock_release(ds->ossl_lock);
} | Variant | 0 |
static pj_status_t transport_destroy(pjmedia_transport *tp)
{
struct transport_udp *udp = (struct transport_udp*) tp;
/* Sanity check */
PJ_ASSERT_RETURN(tp, PJ_EINVAL);
/* Must not close while application is using this */
//PJ_ASSERT_RETURN(!udp->attached, PJ_EINVALIDOP);
if (udp->rtp_key) {
/* This will block the execution if callback is still
* being called.
*/
pj_ioqueue_unregister(udp->rtp_key);
udp->rtp_key = NULL;
udp->rtp_sock = PJ_INVALID_SOCKET;
} else if (udp->rtp_sock != PJ_INVALID_SOCKET) {
pj_sock_close(udp->rtp_sock);
udp->rtp_sock = PJ_INVALID_SOCKET;
}
if (udp->rtcp_key) {
pj_ioqueue_unregister(udp->rtcp_key);
udp->rtcp_key = NULL;
udp->rtcp_sock = PJ_INVALID_SOCKET;
} else if (udp->rtcp_sock != PJ_INVALID_SOCKET) {
pj_sock_close(udp->rtcp_sock);
udp->rtcp_sock = PJ_INVALID_SOCKET;
}
PJ_LOG(4,(udp->base.name, "UDP media transport destroyed"));
pj_pool_release(udp->pool);
return PJ_SUCCESS;
} | Variant | 0 |
static RzList /*<RzDebugMap *>*/ *__io_maps(RzDebug *dbg) {
RzList *list = rz_list_new();
char *str = dbg->iob.system(dbg->iob.io, "dm");
if (!str) {
rz_list_free(list);
return NULL;
}
char *ostr = str;
ut64 map_start, map_end;
char perm[32];
char name[512];
for (;;) {
char *nl = strchr(str, '\n');
if (nl) {
*nl = 0;
*name = 0;
*perm = 0;
map_start = map_end = 0LL;
if (!strncmp(str, "sys ", 4)) {
char *sp = strchr(str + 4, ' ');
if (sp) {
str = sp + 1;
} else {
str += 4;
}
}
char *_s_ = strstr(str, " s ");
if (_s_) {
memmove(_s_, _s_ + 2, strlen(_s_));
}
_s_ = strstr(str, " ? ");
if (_s_) {
memmove(_s_, _s_ + 2, strlen(_s_));
}
sscanf(str, "0x%" PFMT64x " - 0x%" PFMT64x " %s %s",
&map_start, &map_end, perm, name);
if (map_end != 0LL) {
RzDebugMap *map = rz_debug_map_new(name, map_start, map_end, rz_str_rwx(perm), 0);
rz_list_append(list, map);
}
str = nl + 1;
} else {
break;
}
}
free(ostr);
rz_cons_reset();
return list;
} | Base | 1 |
static RzList /*<RzDebugMap *>*/ *__io_maps(RzDebug *dbg) {
RzList *list = rz_list_new();
char *str = dbg->iob.system(dbg->iob.io, "dm");
if (!str) {
rz_list_free(list);
return NULL;
}
char *ostr = str;
ut64 map_start, map_end;
char perm[32];
char name[512];
for (;;) {
char *nl = strchr(str, '\n');
if (nl) {
*nl = 0;
*name = 0;
*perm = 0;
map_start = map_end = 0LL;
if (!strncmp(str, "sys ", 4)) {
char *sp = strchr(str + 4, ' ');
if (sp) {
str = sp + 1;
} else {
str += 4;
}
}
char *_s_ = strstr(str, " s ");
if (_s_) {
memmove(_s_, _s_ + 2, strlen(_s_));
}
_s_ = strstr(str, " ? ");
if (_s_) {
memmove(_s_, _s_ + 2, strlen(_s_));
}
sscanf(str, "0x%" PFMT64x " - 0x%" PFMT64x " %s %s",
&map_start, &map_end, perm, name);
if (map_end != 0LL) {
RzDebugMap *map = rz_debug_map_new(name, map_start, map_end, rz_str_rwx(perm), 0);
rz_list_append(list, map);
}
str = nl + 1;
} else {
break;
}
}
free(ostr);
rz_cons_reset();
return list;
} | Variant | 0 |
char* parse_content_length( char* buffer, char* end, int* length)
{
int number;
char *p;
int size;
p = buffer;
/* search the beginning of the number */
while ( p<end && (*p==' ' || *p=='\t' || (*p=='\r' && *(p+1)=='\n') ||
(*p=='\n' && (*(p+1)==' '||*(p+1)=='\t')) ))
p++;
if (p==end)
goto error;
/* parse the number */
size = 0;
number = 0;
while (p<end && *p>='0' && *p<='9') {
number = number*10 + (*p)-'0';
if (number<0) {
LM_ERR("number overflow at pos %d in len number [%.*s]\n",
(int)(p-buffer),(int)(end-buffer), buffer);
return 0;
}
size ++;
p++;
}
if (p==end || size==0)
goto error;
/* now we should have only spaces at the end */
while ( p<end && (*p==' ' || *p=='\t' ||
(*p=='\n' && (*(p+1)==' '||*(p+1)=='\t')) ))
p++;
if (p==end)
goto error;
/* the header ends proper? */
if ( (*(p++)!='\n') && (*(p-1)!='\r' || *(p++)!='\n' ) )
goto error;
*length = number;
return p;
error:
LM_ERR("parse error near char [%d][%c]\n",*p,*p);
return 0;
} | Base | 1 |
print_perm_line (int idx,
GPtrArray *items,
int cols)
{
g_autoptr(GString) res = g_string_new (NULL);
int i;
g_string_append_printf (res, " [%d] %s", idx, (char *) items->pdata[0]);
for (i = 1; i < items->len; i++)
{
char *p;
int len;
p = strrchr (res->str, '\n');
if (!p)
p = res->str;
len = (res->str + strlen (res->str)) - p;
if (len + strlen ((char *) items->pdata[i]) + 2 >= cols)
g_string_append_printf (res, ",\n %s", (char *) items->pdata[i]);
else
g_string_append_printf (res, ", %s", (char *) items->pdata[i]);
}
g_print ("%s\n", res->str);
} | Class | 2 |
load_kernel_module_list (void)
{
GHashTable *modules = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
g_autofree char *modules_data = NULL;
g_autoptr(GError) error = NULL;
char *start, *end;
if (!g_file_get_contents ("/proc/modules", &modules_data, NULL, &error))
{
g_info ("Failed to read /proc/modules: %s", error->message);
return modules;
}
/* /proc/modules is a table of modules.
* Columns are split by spaces and rows by newlines.
* The first column is the name. */
start = modules_data;
while (TRUE)
{
end = strchr (start, ' ');
if (end == NULL)
break;
g_hash_table_add (modules, g_strndup (start, (end - start)));
start = strchr (end, '\n');
if (start == NULL)
break;
start++;
}
return modules;
} | Class | 2 |
flatpak_context_set_persistent (FlatpakContext *context,
const char *path)
{
g_hash_table_insert (context->persistent, g_strdup (path), GINT_TO_POINTER (1));
} | Class | 2 |
option_persist_cb (const gchar *option_name,
const gchar *value,
gpointer data,
GError **error)
{
FlatpakContext *context = data;
flatpak_context_set_persistent (context, value);
return TRUE;
} | Class | 2 |
context_parse_args (FlatpakContext *context,
...)
{
g_autoptr(GError) local_error = NULL;
g_autoptr(GOptionContext) oc = NULL;
g_autoptr(GOptionGroup) group = NULL;
g_autoptr(GPtrArray) args = g_ptr_array_new_with_free_func (g_free);
g_auto(GStrv) argv = NULL;
const char *arg;
va_list ap;
g_ptr_array_add (args, g_strdup ("argv[0]"));
va_start (ap, context);
while ((arg = va_arg (ap, const char *)) != NULL)
g_ptr_array_add (args, g_strdup (arg));
va_end (ap);
g_ptr_array_add (args, NULL);
argv = (GStrv) g_ptr_array_free (g_steal_pointer (&args), FALSE);
oc = g_option_context_new ("");
group = flatpak_context_get_options (context);
g_option_context_add_group (oc, group);
g_option_context_parse_strv (oc, &argv, &local_error);
g_assert_no_error (local_error);
} | Class | 2 |
struct mosquitto *context__init(mosq_sock_t sock)
{
struct mosquitto *context;
char address[1024];
context = mosquitto__calloc(1, sizeof(struct mosquitto));
if(!context) return NULL;
#ifdef WITH_EPOLL
context->ident = id_client;
#else
context->pollfd_index = -1;
#endif
mosquitto__set_state(context, mosq_cs_new);
context->sock = sock;
context->last_msg_in = db.now_s;
context->next_msg_out = db.now_s + 60;
context->keepalive = 60; /* Default to 60s */
context->clean_start = true;
context->id = NULL;
context->last_mid = 0;
context->will = NULL;
context->username = NULL;
context->password = NULL;
context->listener = NULL;
context->acl_list = NULL;
context->retain_available = true;
/* is_bridge records whether this client is a bridge or not. This could be
* done by looking at context->bridge for bridges that we create ourself,
* but incoming bridges need some other way of being recorded. */
context->is_bridge = false;
context->in_packet.payload = NULL;
packet__cleanup(&context->in_packet);
context->out_packet = NULL;
context->current_out_packet = NULL;
context->out_packet_count = 0;
context->address = NULL;
if((int)sock >= 0){
if(!net__socket_get_address(sock, address, 1024, &context->remote_port)){
context->address = mosquitto__strdup(address);
}
if(!context->address){
/* getpeername and inet_ntop failed and not a bridge */
mosquitto__free(context);
return NULL;
}
}
context->bridge = NULL;
context->msgs_in.inflight_maximum = db.config->max_inflight_messages;
context->msgs_out.inflight_maximum = db.config->max_inflight_messages;
context->msgs_in.inflight_quota = db.config->max_inflight_messages;
context->msgs_out.inflight_quota = db.config->max_inflight_messages;
context->max_qos = 2;
#ifdef WITH_TLS
context->ssl = NULL;
#endif
if((int)context->sock >= 0){
HASH_ADD(hh_sock, db.contexts_by_sock, sock, sizeof(context->sock), context);
}
return context;
} | Variant | 0 |
void context__cleanup(struct mosquitto *context, bool force_free)
{
struct mosquitto__packet *packet;
if(!context) return;
if(force_free){
context->clean_start = true;
}
#ifdef WITH_BRIDGE
if(context->bridge){
bridge__cleanup(context);
}
#endif
alias__free_all(context);
mosquitto__free(context->auth_method);
context->auth_method = NULL;
mosquitto__free(context->username);
context->username = NULL;
mosquitto__free(context->password);
context->password = NULL;
net__socket_close(context);
if(force_free){
sub__clean_session(context);
}
db__messages_delete(context, force_free);
mosquitto__free(context->address);
context->address = NULL;
context__send_will(context);
if(context->id){
context__remove_from_by_id(context);
mosquitto__free(context->id);
context->id = NULL;
}
packet__cleanup(&(context->in_packet));
if(context->current_out_packet){
packet__cleanup(context->current_out_packet);
mosquitto__free(context->current_out_packet);
context->current_out_packet = NULL;
}
while(context->out_packet){
packet__cleanup(context->out_packet);
packet = context->out_packet;
context->out_packet = context->out_packet->next;
mosquitto__free(packet);
}
context->out_packet_count = 0;
#if defined(WITH_BROKER) && defined(__GLIBC__) && defined(WITH_ADNS)
if(context->adns){
gai_cancel(context->adns);
mosquitto__free((struct addrinfo *)context->adns->ar_request);
mosquitto__free(context->adns);
}
#endif
if(force_free){
mosquitto__free(context);
}
} | Variant | 0 |
int db__message_store_find(struct mosquitto *context, uint16_t mid, struct mosquitto_msg_store **stored)
{
struct mosquitto_client_msg *tail;
if(!context) return MOSQ_ERR_INVAL;
*stored = NULL;
DL_FOREACH(context->msgs_in.inflight, tail){
if(tail->store->source_mid == mid){
*stored = tail->store;
return MOSQ_ERR_SUCCESS;
}
}
DL_FOREACH(context->msgs_in.queued, tail){
if(tail->store->source_mid == mid){
*stored = tail->store;
return MOSQ_ERR_SUCCESS;
}
}
return 1;
} | Variant | 0 |
match_expr(struct search_node_list *head, struct eventlog *evlog, bool last_match)
{
struct search_node *sn;
bool res = false, matched = last_match;
int rc;
debug_decl(match_expr, SUDO_DEBUG_UTIL);
STAILQ_FOREACH(sn, head, entries) {
switch (sn->type) {
case ST_EXPR:
res = match_expr(&sn->u.expr, evlog, matched);
break;
case ST_CWD:
if (evlog->cwd != NULL)
res = strcmp(sn->u.cwd, evlog->cwd) == 0;
break;
case ST_HOST:
if (evlog->submithost != NULL)
res = strcmp(sn->u.host, evlog->submithost) == 0;
break;
case ST_TTY:
if (evlog->ttyname != NULL)
res = strcmp(sn->u.tty, evlog->ttyname) == 0;
break;
case ST_RUNASGROUP:
if (evlog->rungroup != NULL)
res = strcmp(sn->u.runas_group, evlog->rungroup) == 0;
break;
case ST_RUNASUSER:
if (evlog->runuser != NULL)
res = strcmp(sn->u.runas_user, evlog->runuser) == 0;
break;
case ST_USER:
if (evlog->submituser != NULL)
res = strcmp(sn->u.user, evlog->submituser) == 0;
break;
case ST_PATTERN:
rc = regexec(&sn->u.cmdre, evlog->command, 0, NULL, 0);
if (rc && rc != REG_NOMATCH) {
char buf[BUFSIZ];
regerror(rc, &sn->u.cmdre, buf, sizeof(buf));
sudo_fatalx("%s", buf);
}
res = rc == REG_NOMATCH ? 0 : 1;
break;
case ST_FROMDATE:
res = sudo_timespeccmp(&evlog->submit_time, &sn->u.tstamp, >=);
break;
case ST_TODATE:
res = sudo_timespeccmp(&evlog->submit_time, &sn->u.tstamp, <=);
break;
default:
sudo_fatalx(U_("unknown search type %d"), sn->type);
/* NOTREACHED */
}
if (sn->negated)
res = !res;
matched = sn->or ? (res || last_match) : (res && last_match);
last_match = matched;
}
debug_return_bool(matched);
} | Class | 2 |
match_expr(struct search_node_list *head, struct eventlog *evlog, bool last_match)
{
struct search_node *sn;
bool res = false, matched = last_match;
int rc;
debug_decl(match_expr, SUDO_DEBUG_UTIL);
STAILQ_FOREACH(sn, head, entries) {
switch (sn->type) {
case ST_EXPR:
res = match_expr(&sn->u.expr, evlog, matched);
break;
case ST_CWD:
if (evlog->cwd != NULL)
res = strcmp(sn->u.cwd, evlog->cwd) == 0;
break;
case ST_HOST:
if (evlog->submithost != NULL)
res = strcmp(sn->u.host, evlog->submithost) == 0;
break;
case ST_TTY:
if (evlog->ttyname != NULL)
res = strcmp(sn->u.tty, evlog->ttyname) == 0;
break;
case ST_RUNASGROUP:
if (evlog->rungroup != NULL)
res = strcmp(sn->u.runas_group, evlog->rungroup) == 0;
break;
case ST_RUNASUSER:
if (evlog->runuser != NULL)
res = strcmp(sn->u.runas_user, evlog->runuser) == 0;
break;
case ST_USER:
if (evlog->submituser != NULL)
res = strcmp(sn->u.user, evlog->submituser) == 0;
break;
case ST_PATTERN:
rc = regexec(&sn->u.cmdre, evlog->command, 0, NULL, 0);
if (rc && rc != REG_NOMATCH) {
char buf[BUFSIZ];
regerror(rc, &sn->u.cmdre, buf, sizeof(buf));
sudo_fatalx("%s", buf);
}
res = rc == REG_NOMATCH ? 0 : 1;
break;
case ST_FROMDATE:
res = sudo_timespeccmp(&evlog->submit_time, &sn->u.tstamp, >=);
break;
case ST_TODATE:
res = sudo_timespeccmp(&evlog->submit_time, &sn->u.tstamp, <=);
break;
default:
sudo_fatalx(U_("unknown search type %d"), sn->type);
/* NOTREACHED */
}
if (sn->negated)
res = !res;
matched = sn->or ? (res || last_match) : (res && last_match);
last_match = matched;
}
debug_return_bool(matched);
} | Class | 2 |
list_session(char *log_dir, regex_t *re, const char *user, const char *tty)
{
char idbuf[7], *idstr, *cp;
struct eventlog *evlog = NULL;
const char *timestr;
int ret = -1;
debug_decl(list_session, SUDO_DEBUG_UTIL);
if ((evlog = iolog_parse_loginfo(-1, log_dir)) == NULL)
goto done;
if (evlog->command == NULL || evlog->submituser == NULL ||
evlog->runuser == NULL) {
goto done;
}
/* Match on search expression if there is one. */
if (!STAILQ_EMPTY(&search_expr) && !match_expr(&search_expr, evlog, true))
goto done;
/* Convert from /var/log/sudo-sessions/00/00/01 to 000001 */
cp = log_dir + strlen(session_dir) + 1;
if (IS_IDLOG(cp)) {
idbuf[0] = cp[0];
idbuf[1] = cp[1];
idbuf[2] = cp[3];
idbuf[3] = cp[4];
idbuf[4] = cp[6];
idbuf[5] = cp[7];
idbuf[6] = '\0';
idstr = idbuf;
} else {
/* Not an id, use as-is. */
idstr = cp;
}
/* XXX - print lines + cols? */
timestr = get_timestr(evlog->submit_time.tv_sec, 1);
printf("%s : %s : ", timestr ? timestr : "invalid date", evlog->submituser);
if (evlog->submithost != NULL)
printf("HOST=%s ; ", evlog->submithost);
if (evlog->ttyname != NULL)
printf("TTY=%s ; ", evlog->ttyname);
if (evlog->runchroot != NULL)
printf("CHROOT=%s ; ", evlog->runchroot);
if (evlog->runcwd != NULL || evlog->cwd != NULL)
printf("CWD=%s ; ", evlog->runcwd ? evlog->runcwd : evlog->cwd);
printf("USER=%s ; ", evlog->runuser);
if (evlog->rungroup != NULL)
printf("GROUP=%s ; ", evlog->rungroup);
printf("TSID=%s ; COMMAND=%s\n", idstr, evlog->command);
ret = 0;
done:
eventlog_free(evlog);
debug_return_int(ret);
} | Class | 2 |
list_session(char *log_dir, regex_t *re, const char *user, const char *tty)
{
char idbuf[7], *idstr, *cp;
struct eventlog *evlog = NULL;
const char *timestr;
int ret = -1;
debug_decl(list_session, SUDO_DEBUG_UTIL);
if ((evlog = iolog_parse_loginfo(-1, log_dir)) == NULL)
goto done;
if (evlog->command == NULL || evlog->submituser == NULL ||
evlog->runuser == NULL) {
goto done;
}
/* Match on search expression if there is one. */
if (!STAILQ_EMPTY(&search_expr) && !match_expr(&search_expr, evlog, true))
goto done;
/* Convert from /var/log/sudo-sessions/00/00/01 to 000001 */
cp = log_dir + strlen(session_dir) + 1;
if (IS_IDLOG(cp)) {
idbuf[0] = cp[0];
idbuf[1] = cp[1];
idbuf[2] = cp[3];
idbuf[3] = cp[4];
idbuf[4] = cp[6];
idbuf[5] = cp[7];
idbuf[6] = '\0';
idstr = idbuf;
} else {
/* Not an id, use as-is. */
idstr = cp;
}
/* XXX - print lines + cols? */
timestr = get_timestr(evlog->submit_time.tv_sec, 1);
printf("%s : %s : ", timestr ? timestr : "invalid date", evlog->submituser);
if (evlog->submithost != NULL)
printf("HOST=%s ; ", evlog->submithost);
if (evlog->ttyname != NULL)
printf("TTY=%s ; ", evlog->ttyname);
if (evlog->runchroot != NULL)
printf("CHROOT=%s ; ", evlog->runchroot);
if (evlog->runcwd != NULL || evlog->cwd != NULL)
printf("CWD=%s ; ", evlog->runcwd ? evlog->runcwd : evlog->cwd);
printf("USER=%s ; ", evlog->runuser);
if (evlog->rungroup != NULL)
printf("GROUP=%s ; ", evlog->rungroup);
printf("TSID=%s ; COMMAND=%s\n", idstr, evlog->command);
ret = 0;
done:
eventlog_free(evlog);
debug_return_int(ret);
} | Class | 2 |
int valid_field (const char *field, const char *illegal)
{
const char *cp;
int err = 0;
if (NULL == field) {
return -1;
}
/* For each character of field, search if it appears in the list
* of illegal characters. */
for (cp = field; '\0' != *cp; cp++) {
if (strchr (illegal, *cp) != NULL) {
err = -1;
break;
}
}
if (0 == err) {
/* Search if there are some non-printable characters */
for (cp = field; '\0' != *cp; cp++) {
if (!isprint (*cp)) {
err = 1;
break;
}
}
}
return err;
} | Class | 2 |
static u32 crc32sum(u32 crc, u8 * RESTRICT buf, size_t size) {
while (size--) crc = crc32Table[(crc ^ *(buf++)) & 0xff] ^ (crc >> 8);
return crc;
} | Base | 1 |
static void mrled(u8 * RESTRICT in, u8 * RESTRICT out, s32 outlen) {
s32 op = 0, ip = 0;
s32 c, pc = -1;
s32 t[256] = { 0 };
s32 run = 0;
for (s32 i = 0; i < 32; ++i) {
c = in[ip++];
for (s32 j = 0; j < 8; ++j) t[i * 8 + j] = (c >> j) & 1;
}
while (op < outlen) {
c = in[ip++];
if (t[c]) {
for (run = 0; (pc = in[ip++]) == 255; run += 255)
;
run += pc + 1;
for (; run > 0 && op < outlen; --run) out[op++] = c;
} else
out[op++] = c;
}
} | Base | 1 |
BZIP3_API struct bz3_state * bz3_new(s32 block_size) {
if (block_size < KiB(65) || block_size > MiB(511)) {
return NULL;
}
struct bz3_state * bz3_state = malloc(sizeof(struct bz3_state));
if (!bz3_state) {
return NULL;
}
bz3_state->cm_state = malloc(sizeof(state));
bz3_state->swap_buffer = malloc(bz3_bound(block_size));
bz3_state->sais_array = malloc((block_size + 128) * sizeof(s32));
memset(bz3_state->sais_array, 0, sizeof(s32) * (block_size + 128));
bz3_state->lzp_lut = calloc(1 << LZP_DICTIONARY, sizeof(s32));
if (!bz3_state->cm_state || !bz3_state->swap_buffer || !bz3_state->sais_array || !bz3_state->lzp_lut) {
if (bz3_state->cm_state) free(bz3_state->cm_state);
if (bz3_state->swap_buffer) free(bz3_state->swap_buffer);
if (bz3_state->sais_array) free(bz3_state->sais_array);
if (bz3_state->lzp_lut) free(bz3_state->lzp_lut);
free(bz3_state);
return NULL;
}
bz3_state->block_size = block_size;
bz3_state->last_error = BZ3_OK;
return bz3_state;
} | Base | 1 |
int dns_add_rr_nested_memcpy(struct dns_rr_nested *rr_nested, void *data, int data_len)
{
if (rr_nested == NULL || data == NULL || data_len <= 0) {
return -1;
}
if (_dns_left_len(&rr_nested->context) < data_len) {
return -1;
}
memcpy(rr_nested->context.ptr, data, data_len);
rr_nested->context.ptr += data_len;
return 0;
} | Base | 1 |
int dns_HTTPS_add_ipv4hint(struct dns_rr_nested *svcparam, unsigned char addr[][DNS_RR_A_LEN], int addr_num)
{
if (_dns_left_len(&svcparam->context) < 4 + addr_num * DNS_RR_A_LEN) {
return -1;
}
unsigned short value = DNS_HTTPS_T_IPV4HINT;
dns_add_rr_nested_memcpy(svcparam, &value, 2);
value = addr_num * DNS_RR_A_LEN;
dns_add_rr_nested_memcpy(svcparam, &value, 2);
for (int i = 0; i < addr_num; i++) {
dns_add_rr_nested_memcpy(svcparam, addr[i], DNS_RR_A_LEN);
}
return 0;
} | Base | 1 |
int dns_HTTPS_add_ipv6hint(struct dns_rr_nested *svcparam, unsigned char addr[][DNS_RR_AAAA_LEN], int addr_num)
{
if (_dns_left_len(&svcparam->context) < 4 + addr_num * DNS_RR_AAAA_LEN) {
return -1;
}
unsigned short value = DNS_HTTPS_T_IPV6HINT;
dns_add_rr_nested_memcpy(svcparam, &value, 2);
value = addr_num * DNS_RR_AAAA_LEN;
dns_add_rr_nested_memcpy(svcparam, &value, 2);
for (int i = 0; i < addr_num; i++) {
dns_add_rr_nested_memcpy(svcparam, addr[i], DNS_RR_AAAA_LEN);
}
return 0;
} | Base | 1 |
static int _dns_encode_HTTPS(struct dns_context *context, struct dns_rrs *rrs)
{
int ret = 0;
int qtype = 0;
int qclass = 0;
char domain[DNS_MAX_CNAME_LEN];
char target[DNS_MAX_CNAME_LEN] = {0};
unsigned char *rr_len_ptr = NULL;
unsigned char *start = NULL;
unsigned char *rr_start = NULL;
int ttl = 0;
int priority = 0;
struct dns_https_param *param = NULL;
param = dns_get_HTTPS_svcparm_start(rrs, domain, DNS_MAX_CNAME_LEN, &ttl, &priority, target, DNS_MAX_CNAME_LEN);
if (param == NULL) {
tlog(TLOG_ERROR, "get https param failed.");
return -1;
}
ret = _dns_encode_rr_head(context, domain, qtype, qclass, ttl, 0, &rr_len_ptr);
if (ret < 0) {
return -1;
}
rr_start = context->ptr;
if (_dns_left_len(context) < 2) {
tlog(TLOG_ERROR, "left len is invalid.");
return -1;
}
_dns_write_short(&context->ptr, priority);
ret = _dns_encode_domain(context, target);
if (ret < 0) {
return -1;
}
start = context->ptr;
for (; param != NULL; param = dns_get_HTTPS_svcparm_next(rrs, param)) {
if (context->ptr - start > rrs->len || _dns_left_len(context) <= 0) {
return -1;
}
_dns_write_short(&context->ptr, param->key);
_dns_write_short(&context->ptr, param->len);
switch (param->key) {
case DNS_HTTPS_T_MANDATORY:
case DNS_HTTPS_T_NO_DEFAULT_ALPN:
case DNS_HTTPS_T_ALPN:
case DNS_HTTPS_T_PORT:
case DNS_HTTPS_T_IPV4HINT:
case DNS_HTTPS_T_ECH:
case DNS_HTTPS_T_IPV6HINT: {
memcpy(context->ptr, param->value, param->len);
context->ptr += param->len;
} break;
default:
/* skip unknown key */
context->ptr -= 4;
break;
}
}
_dns_write_short(&rr_len_ptr, context->ptr - rr_start);
return 0;
} | Base | 1 |
int dns_add_HTTPS_start(struct dns_rr_nested *svcparam_buffer, struct dns_packet *packet, dns_rr_type type,
const char *domain, int ttl, int priority, const char *target)
{
svcparam_buffer = dns_add_rr_nested_start(svcparam_buffer, packet, type, DNS_T_HTTPS, domain, ttl);
if (svcparam_buffer == NULL) {
return -1;
}
int target_len = strnlen(target, DNS_MAX_CNAME_LEN) + 1;
if (_dns_left_len(&svcparam_buffer->context) < 2 + target_len) {
return -1;
}
/* add rr data */
_dns_write_short(&svcparam_buffer->context.ptr, priority);
safe_strncpy((char *)svcparam_buffer->context.ptr, target, target_len);
svcparam_buffer->context.ptr += target_len;
return 0;
} | Base | 1 |
struct dns_https_param *dns_get_HTTPS_svcparm_start(struct dns_rrs *rrs, char *domain, int maxsize, int *ttl,
int *priority, char *target, int target_size)
{
int qtype = 0;
unsigned char *data = NULL;
int rr_len = 0;
data = dns_get_rr_nested_start(rrs, domain, maxsize, &qtype, ttl, &rr_len);
if (data == NULL) {
return NULL;
}
if (qtype != DNS_T_HTTPS) {
return NULL;
}
if (rr_len < 2) {
return NULL;
}
*priority = _dns_read_short(&data);
rr_len -= 2;
if (rr_len <= 0) {
return NULL;
}
int len = strnlen((char *)data, rr_len);
safe_strncpy(target, (char *)data, target_size);
data += len + 1;
rr_len -= len + 1;
if (rr_len <= 0) {
return NULL;
}
return (struct dns_https_param *)data;
} | Base | 1 |
PrintBackend *cpdbCreateBackendFromFile(GDBusConnection *connection,
const char *backend_file_name)
{
FILE *file = NULL;
PrintBackend *proxy;
GError *error = NULL;
char *path, *backend_name;
const char *info_dir_name;
char obj_path[CPDB_BSIZE];
backend_name = cpdbGetStringCopy(backend_file_name);
if ((info_dir_name = getenv("CPDB_BACKEND_INFO_DIR")) == NULL)
info_dir_name = CPDB_BACKEND_INFO_DIR;
path = cpdbConcatPath(info_dir_name, backend_file_name);
if ((file = fopen(path, "r")) == NULL)
{
logerror("Error creating backend %s : Couldn't open %s for reading\n",
backend_name, path);
free(path);
return NULL;
}
if (fscanf(file, "%s", obj_path) == 0)
{
logerror("Error creating backend %s : Couldn't parse %s\n",
backend_name, path);
free(path);
fclose(file);
return NULL;
}
free(path);
fclose(file);
proxy = print_backend_proxy_new_sync(connection,
0,
backend_name,
obj_path,
NULL,
&error);
if (error)
{
logerror("Error creating backend proxy for %s : %s\n",
backend_name, error->message);
return NULL;
}
return proxy;
} | Variant | 0 |
int pico_tcp_initconn(struct pico_socket *s)
{
struct pico_socket_tcp *ts = TCP_SOCK(s);
struct pico_frame *syn;
struct pico_tcp_hdr *hdr;
uint16_t mtu, opt_len = tcp_options_size(ts, PICO_TCP_SYN);
syn = s->net->alloc(s->stack, s->net, NULL, (uint16_t)(PICO_SIZE_TCPHDR + opt_len));
if (!syn)
return -1;
hdr = (struct pico_tcp_hdr *) syn->transport_hdr;
if (!ts->snd_nxt)
ts->snd_nxt = long_be(pico_paws());
ts->snd_last = ts->snd_nxt;
ts->cwnd = PICO_TCP_IW;
mtu = (uint16_t)pico_socket_get_mss(s);
ts->mss = (uint16_t)(mtu - PICO_SIZE_TCPHDR);
ts->ssthresh = (uint16_t)((uint16_t)(PICO_DEFAULT_SOCKETQ / ts->mss) - (((uint16_t)(PICO_DEFAULT_SOCKETQ / ts->mss)) >> 3u));
syn->sock = s;
hdr->seq = long_be(ts->snd_nxt);
hdr->len = (uint8_t)((PICO_SIZE_TCPHDR + opt_len) << 2);
hdr->flags = PICO_TCP_SYN;
tcp_set_space(ts);
hdr->rwnd = short_be(ts->wnd);
tcp_add_options(ts, syn, PICO_TCP_SYN, opt_len);
hdr->trans.sport = ts->sock.local_port;
hdr->trans.dport = ts->sock.remote_port;
hdr->crc = 0;
hdr->crc = short_be(pico_tcp_checksum(syn));
/* TCP: ENQUEUE to PROTO ( SYN ) */
tcp_dbg("Sending SYN... (ports: %d - %d) size: %d\n", short_be(ts->sock.local_port), short_be(ts->sock.remote_port), syn->buffer_len);
ts->retrans_tmr = pico_timer_add(s->stack, PICO_TCP_SYN_TO << ts->backoff, initconn_retry, ts);
if (!ts->retrans_tmr) {
tcp_dbg("TCP: Failed to start initconn_retry timer\n");
PICO_FREE(syn);
return -1;
}
pico_enqueue(&s->stack->q_tcp.out, syn);
return 0;
} | Base | 1 |
struct pico_socket *pico_tcp_open(struct pico_stack *S, uint16_t family)
{
struct pico_socket_tcp *t = PICO_ZALLOC(sizeof(struct pico_socket_tcp));
if (!t)
return NULL;
t->sock.stack = S;
t->sock.timestamp = TCP_TIME;
pico_socket_set_family(&t->sock, family);
t->mss = (uint16_t)(pico_socket_get_mss(&t->sock) - PICO_SIZE_TCPHDR);
t->tcpq_in.pool.root = t->tcpq_hold.pool.root = t->tcpq_out.pool.root = &LEAF;
t->tcpq_hold.pool.compare = t->tcpq_out.pool.compare = segment_compare;
t->tcpq_in.pool.compare = input_segment_compare;
t->tcpq_in.max_size = PICO_DEFAULT_SOCKETQ;
t->tcpq_out.max_size = PICO_DEFAULT_SOCKETQ;
t->tcpq_hold.max_size = 2u * t->mss;
rto_set(t, PICO_TCP_RTO_MIN);
/* Uncomment next line and disable Nagle by default */
t->sock.opt_flags |= (1 << PICO_SOCKET_OPT_TCPNODELAY);
/* Uncomment next line and Nagle is enabled by default */
/* t->sock.opt_flags &= (uint16_t) ~(1 << PICO_SOCKET_OPT_TCPNODELAY); */
/* Set default linger for the socket */
t->linger_timeout = PICO_SOCKET_LINGER_TIMEOUT;
#ifdef PICO_TCP_SUPPORT_SOCKET_STATS
if (!pico_timer_add(t->sock.stack, 2000, sock_stats, t)) {
tcp_dbg("TCP: Failed to start socket statistics timer\n");
PICO_FREE(t);
return NULL;
}
#endif
t->keepalive_tmr = pico_timer_add(t->sock.stack, 1000, pico_tcp_keepalive, t);
if (!t->keepalive_tmr) {
tcp_dbg("TCP: Failed to start keepalive timer\n");
PICO_FREE(t);
return NULL;
}
tcp_set_space(t);
return &t->sock;
} | Base | 1 |
_xdr_kadm5_principal_ent_rec(XDR *xdrs, kadm5_principal_ent_rec *objp,
int v)
{
unsigned int n;
if (!xdr_krb5_principal(xdrs, &objp->principal)) {
return (FALSE);
}
if (!xdr_krb5_timestamp(xdrs, &objp->princ_expire_time)) {
return (FALSE);
}
if (!xdr_krb5_timestamp(xdrs, &objp->last_pwd_change)) {
return (FALSE);
}
if (!xdr_krb5_timestamp(xdrs, &objp->pw_expiration)) {
return (FALSE);
}
if (!xdr_krb5_deltat(xdrs, &objp->max_life)) {
return (FALSE);
}
if (!xdr_nulltype(xdrs, (void **) &objp->mod_name,
xdr_krb5_principal)) {
return (FALSE);
}
if (!xdr_krb5_timestamp(xdrs, &objp->mod_date)) {
return (FALSE);
}
if (!xdr_krb5_flags(xdrs, &objp->attributes)) {
return (FALSE);
}
if (!xdr_krb5_kvno(xdrs, &objp->kvno)) {
return (FALSE);
}
if (!xdr_krb5_kvno(xdrs, &objp->mkvno)) {
return (FALSE);
}
if (!xdr_nullstring(xdrs, &objp->policy)) {
return (FALSE);
}
if (!xdr_long(xdrs, &objp->aux_attributes)) {
return (FALSE);
}
if (!xdr_krb5_deltat(xdrs, &objp->max_renewable_life)) {
return (FALSE);
}
if (!xdr_krb5_timestamp(xdrs, &objp->last_success)) {
return (FALSE);
}
if (!xdr_krb5_timestamp(xdrs, &objp->last_failed)) {
return (FALSE);
}
if (!xdr_krb5_kvno(xdrs, &objp->fail_auth_count)) {
return (FALSE);
}
if (!xdr_krb5_int16(xdrs, &objp->n_key_data)) {
return (FALSE);
}
if (!xdr_krb5_int16(xdrs, &objp->n_tl_data)) {
return (FALSE);
}
if (!xdr_nulltype(xdrs, (void **) &objp->tl_data,
xdr_krb5_tl_data)) {
return FALSE;
}
n = objp->n_key_data;
if (!xdr_array(xdrs, (caddr_t *) &objp->key_data,
&n, ~0, sizeof(krb5_key_data),
xdr_krb5_key_data_nocontents)) {
return (FALSE);
}
return (TRUE);
} | Base | 1 |
DltReturnValue dlt_file_message(DltFile *file, int index, int verbose)
{
PRINT_FUNCTION_VERBOSE(verbose);
if (file == NULL)
return DLT_RETURN_WRONG_PARAMETER;
/* check if message is in range */
if (index >= file->counter) {
dlt_vlog(LOG_WARNING, "Message %d out of range!\r\n", index);
return DLT_RETURN_WRONG_PARAMETER;
}
/* seek to position in file */
if (fseek(file->handle, file->index[index], SEEK_SET) != 0) {
dlt_vlog(LOG_WARNING, "Seek to message %d to position %ld failed!\r\n",
index, file->index[index]);
return DLT_RETURN_ERROR;
}
/* read all header and payload */
if (dlt_file_read_header(file, verbose) < DLT_RETURN_OK)
return DLT_RETURN_ERROR;
if (dlt_file_read_header_extended(file, verbose) < DLT_RETURN_OK)
return DLT_RETURN_ERROR;
if (dlt_file_read_data(file, verbose) < DLT_RETURN_OK)
return DLT_RETURN_ERROR;
/* set current position in file */
file->position = index;
return DLT_RETURN_OK;
} | Base | 1 |
dig_t bn_get_prime(int pos) {
if (pos >= BASIC_TESTS) {
return 0;
}
return primes[pos];
} | Base | 1 |
static int benaloh(void) {
int code = RLC_ERR;
bdpe_t pub, prv;
bn_t a, b;
dig_t in, out;
uint8_t buf[RLC_BN_BITS / 8 + 1];
size_t len;
int result;
bn_null(a);
bn_null(b);
bdpe_null(pub);
bdpe_null(prv);
RLC_TRY {
bn_new(a);
bn_new(b);
bdpe_new(pub);
bdpe_new(prv);
result = cp_bdpe_gen(pub, prv, bn_get_prime(47), RLC_BN_BITS);
TEST_CASE("benaloh encryption/decryption is correct") {
TEST_ASSERT(result == RLC_OK, end);
len = RLC_BN_BITS / 8 + 1;
rand_bytes(buf, 1);
in = buf[0] % bn_get_prime(47);
TEST_ASSERT(cp_bdpe_enc(buf, &len, in, pub) == RLC_OK, end);
TEST_ASSERT(cp_bdpe_dec(&out, buf, len, prv) == RLC_OK, end);
TEST_ASSERT(in == out, end);
} TEST_END;
TEST_CASE("benaloh encryption/decryption is homomorphic") {
TEST_ASSERT(result == RLC_OK, end);
len = RLC_BN_BITS / 8 + 1;
rand_bytes(buf, 1);
in = buf[0] % bn_get_prime(47);
TEST_ASSERT(cp_bdpe_enc(buf, &len, in, pub) == RLC_OK, end);
bn_read_bin(a, buf, len);
rand_bytes(buf, 1);
out = (buf[0] % bn_get_prime(47));
in = (in + out) % bn_get_prime(47);
TEST_ASSERT(cp_bdpe_enc(buf, &len, out, pub) == RLC_OK, end);
bn_read_bin(b, buf, len);
bn_mul(a, a, b);
bn_mod(a, a, pub->n);
len = bn_size_bin(pub->n);
bn_write_bin(buf, len, a);
TEST_ASSERT(cp_bdpe_dec(&out, buf, len, prv) == RLC_OK, end);
TEST_ASSERT(in == out, end);
} TEST_END;
} RLC_CATCH_ANY {
RLC_ERROR(end);
}
code = RLC_OK;
end:
bn_free(a);
bn_free(b);
bdpe_free(pub);
bdpe_free(prv);
return code;
} | Base | 1 |
static void benaloh(void) {
bdpe_t pub, prv;
dig_t in, new;
uint8_t out[RLC_BN_BITS / 8 + 1];
size_t out_len;
bdpe_null(pub);
bdpe_null(prv);
bdpe_new(pub);
bdpe_new(prv);
BENCH_ONE("cp_bdpe_gen", cp_bdpe_gen(pub, prv, bn_get_prime(47),
RLC_BN_BITS), 1);
BENCH_RUN("cp_bdpe_enc") {
out_len = RLC_BN_BITS / 8 + 1;
rand_bytes(out, 1);
in = out[0] % bn_get_prime(47);
BENCH_ADD(cp_bdpe_enc(out, &out_len, in, pub));
cp_bdpe_dec(&new, out, out_len, prv);
} BENCH_END;
BENCH_RUN("cp_bdpe_dec") {
out_len = RLC_BN_BITS / 8 + 1;
rand_bytes(out, 1);
in = out[0] % bn_get_prime(47);
cp_bdpe_enc(out, &out_len, in, pub);
BENCH_ADD(cp_bdpe_dec(&new, out, out_len, prv));
} BENCH_END;
bdpe_free(pub);
bdpe_free(prv);
} | Base | 1 |
static void memory2(void) {
ep2_t a[BENCH];
BENCH_FEW("ep2_null", ep4_null(a[i]), 1);
BENCH_FEW("ep2_new", ep4_new(a[i]), 1);
for (int i = 0; i < BENCH; i++) {
ep2_free(a[i]);
}
for (int i = 0; i < BENCH; i++) {
ep2_new(a[i]);
}
BENCH_FEW("ep2_free", ep4_free(a[i]), 1);
(void)a;
} | Base | 1 |
void bn_make(bn_t a, int digits) {
if (digits < 0) {
RLC_THROW(ERR_NO_VALID);
}
/* Allocate at least one digit. */
digits = RLC_MAX(digits, 1);
#if ALLOC == DYNAMIC
if (digits % RLC_BN_SIZE != 0) {
/* Pad the number of digits to a multiple of the block. */
digits += (RLC_BN_SIZE - digits % RLC_BN_SIZE);
}
if (a != NULL) {
a->dp = NULL;
#if ALIGN == 1
a->dp = (dig_t *)malloc(digits * sizeof(dig_t));
#elif OPSYS == WINDOWS
a->dp = _aligned_malloc(digits * sizeof(dig_t), ALIGN);
#else
int r = posix_memalign((void **)&a->dp, ALIGN, digits * sizeof(dig_t));
if (r == ENOMEM) {
RLC_THROW(ERR_NO_MEMORY);
}
if (r == EINVAL) {
RLC_THROW(ERR_NO_VALID);
}
#endif /* ALIGN */
}
if (a->dp == NULL) {
free((void *)a);
RLC_THROW(ERR_NO_MEMORY);
}
#else
/* Verify if the number of digits is sane. */
if (digits > RLC_BN_SIZE) {
RLC_THROW(ERR_NO_PRECI);
return;
} else {
digits = RLC_BN_SIZE;
}
#endif
if (a != NULL) {
a->used = 1;
a->dp[0] = 0;
a->alloc = digits;
a->sign = RLC_POS;
}
} | Base | 1 |
void bn_grow(bn_t a, int digits) {
#if ALLOC == DYNAMIC
dig_t *t;
if (a->alloc < digits) {
/* At least add RLC_BN_SIZE more digits. */
digits += (RLC_BN_SIZE * 2) - (digits % RLC_BN_SIZE);
t = (dig_t *)realloc(a->dp, (RLC_DIG / 8) * digits);
if (t == NULL) {
RLC_THROW(ERR_NO_MEMORY);
return;
}
a->dp = t;
/* Set the newly allocated digits to zero. */
a->alloc = digits;
}
#elif ALLOC == AUTO
if (digits > RLC_BN_SIZE) {
RLC_THROW(ERR_NO_PRECI);
return;
}
(void)a;
#endif
} | Base | 1 |
void bn_trim(bn_t a) {
if (a->used <= a->alloc) {
while (a->used > 0 && a->dp[a->used - 1] == 0) {
--(a->used);
}
/* Zero can't be negative. */
if (a->used <= 0) {
a->used = 1;
a->dp[0] = 0;
a->sign = RLC_POS;
}
}
} | Base | 1 |
void bn_mxp_slide(bn_t c, const bn_t a, const bn_t b, const bn_t m) {
bn_t tab[RLC_TABLE_SIZE], t, u, r;
int i, j, l, w = 1;
uint8_t *win = RLC_ALLOCA(uint8_t, bn_bits(b));
if (win == NULL) {
RLC_THROW(ERR_NO_MEMORY);
return;
}
if (bn_cmp_dig(m, 1) == RLC_EQ) {
RLC_FREE(win);
bn_zero(c);
return;
}
if (bn_is_zero(b)) {
RLC_FREE(win);
bn_set_dig(c, 1);
return;
}
bn_null(t);
bn_null(u);
bn_null(r);
/* Initialize table. */
for (i = 0; i < RLC_TABLE_SIZE; i++) {
bn_null(tab[i]);
}
/* Find window size. */
i = bn_bits(b);
if (i <= 21) {
w = 2;
} else if (i <= 32) {
w = 3;
} else if (i <= 128) {
w = 4;
} else if (i <= 256) {
w = 5;
} else if (i <= 512) {
w = 6;
} else {
w = 7;
}
RLC_TRY {
for (i = 0; i < (1 << (w - 1)); i++) {
bn_new(tab[i]);
}
bn_new(t);
bn_new(u);
bn_new(r);
bn_mod_pre(u, m);
#if BN_MOD == MONTY
bn_set_dig(r, 1);
bn_mod_monty_conv(r, r, m);
bn_mod_monty_conv(t, a, m);
#else /* BN_MOD == BARRT || BN_MOD == RADIX */
bn_set_dig(r, 1);
bn_copy(t, a);
#endif
bn_copy(tab[0], t);
bn_sqr(t, tab[0]);
bn_mod(t, t, m, u);
/* Create table. */
for (i = 1; i < 1 << (w - 1); i++) {
bn_mul(tab[i], tab[i - 1], t);
bn_mod(tab[i], tab[i], m, u);
}
l = bn_bits(b);
bn_rec_slw(win, &l, b, w);
for (i = 0; i < l; i++) {
if (win[i] == 0) {
bn_sqr(r, r);
bn_mod(r, r, m, u);
} else {
for (j = 0; j < util_bits_dig(win[i]); j++) {
bn_sqr(r, r);
bn_mod(r, r, m, u);
}
bn_mul(r, r, tab[win[i] >> 1]);
bn_mod(r, r, m, u);
}
}
bn_trim(r);
#if BN_MOD == MONTY
bn_mod_monty_back(r, r, m);
#endif
if (bn_sign(b) == RLC_NEG) {
bn_mod_inv(c, r, m);
} else {
bn_copy(c, r);
}
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
for (i = 0; i < (1 << (w - 1)); i++) {
bn_free(tab[i]);
}
bn_free(u);
bn_free(t);
bn_free(r);
RLC_FREE(win);
}
} | Base | 1 |
void bn_gen_prime_stron(bn_t a, int bits) {
dig_t i, j;
int found, k;
bn_t r, s, t;
bn_null(r);
bn_null(s);
bn_null(t);
RLC_TRY {
bn_new(r);
bn_new(s);
bn_new(t);
do {
do {
/* Generate two large primes r and s. */
bn_rand(s, RLC_POS, bits / 2 - RLC_DIG / 2);
bn_rand(t, RLC_POS, bits / 2 - RLC_DIG / 2);
} while (!bn_is_prime(s) || !bn_is_prime(t));
found = 1;
bn_rand(a, RLC_POS, bits / 2 - bn_bits(t) - 1);
i = a->dp[0];
bn_dbl(t, t);
do {
/* Find first prime r = 2 * i * t + 1. */
bn_mul_dig(r, t, i);
bn_add_dig(r, r, 1);
i++;
if (bn_bits(r) > bits / 2 - 1) {
found = 0;
break;
}
} while (!bn_is_prime(r));
if (found == 0) {
continue;
}
/* Compute t = 2 * (s^(r-2) mod r) * s - 1. */
bn_sub_dig(t, r, 2);
#if BN_MOD != PMERS
bn_mxp(t, s, t, r);
#else
bn_exp(t, s, t, r);
#endif
bn_mul(t, t, s);
bn_dbl(t, t);
bn_sub_dig(t, t, 1);
k = bits - bn_bits(r);
k -= bn_bits(s);
bn_rand(a, RLC_POS, k);
j = a->dp[0];
do {
/* Find first prime a = t + 2 * j * r * s. */
bn_mul(a, r, s);
bn_mul_dig(a, a, j);
bn_dbl(a, a);
bn_add(a, a, t);
j++;
if (bn_bits(a) > bits) {
found = 0;
break;
}
} while (!bn_is_prime(a));
} while (found == 0 && bn_bits(a) != bits);
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
bn_free(r);
bn_free(s);
bn_free(t);
}
} | Base | 1 |
void bn_gen_prime_basic(bn_t a, int bits) {
while (1) {
do {
bn_rand(a, RLC_POS, bits);
} while (bn_bits(a) != bits);
if (bn_is_prime(a)) {
return;
}
}
} | Base | 1 |
int bn_gen_prime_factor(bn_t a, bn_t b, int abits, int bbits) {
bn_t t;
int result = RLC_OK;
if (! (bbits>abits) ) {
return RLC_ERR;
}
bn_null(t);
RLC_TRY {
bn_new(t);
bn_gen_prime(a, abits);
do {
bn_rand(t, RLC_POS, bbits - bn_bits(a));
do {
bn_mul(b, a, t);
bn_add_dig(b, b, 1);
bn_add_dig(t, t, 1);
} while(! bn_is_prime(b));
} while (bn_bits(b) != bbits);
}
RLC_CATCH_ANY {
result = RLC_ERR;
}
RLC_FINALLY {
bn_free(t);
}
return result;
} | Base | 1 |
void bn_gen_prime_safep(bn_t a, int bits) {
while (1) {
do {
bn_rand(a, RLC_POS, bits);
} while (bn_bits(a) != bits);
/* Check if (a - 1)/2 is prime. */
bn_sub_dig(a, a, 1);
bn_rsh(a, a, 1);
if (bn_is_prime(a)) {
/* Restore a. */
bn_lsh(a, a, 1);
bn_add_dig(a, a, 1);
if (bn_is_prime(a)) {
/* Should be prime now. */
return;
}
}
}
} | Base | 1 |
void bn_rec_jsf(int8_t *jsf, int *len, const bn_t k, const bn_t l) {
bn_t n0, n1;
dig_t l0, l1;
int8_t u0, u1, d0, d1;
int i, j, offset;
if (*len < (2 * bn_bits(k) + 1)) {
*len = 0;
RLC_THROW(ERR_NO_BUFFER);
return;
}
bn_null(n0);
bn_null(n1);
RLC_TRY {
bn_new(n0);
bn_new(n1);
bn_abs(n0, k);
bn_abs(n1, l);
i = bn_bits(k);
j = bn_bits(l);
offset = RLC_MAX(i, j) + 1;
memset(jsf, 0, *len);
i = 0;
d0 = d1 = 0;
while (!(bn_is_zero(n0) && d0 == 0) || !(bn_is_zero(n1) && d1 == 0)) {
bn_get_dig(&l0, n0);
bn_get_dig(&l1, n1);
/* For reduction modulo 8. */
l0 = (l0 + d0) & RLC_MASK(3);
l1 = (l1 + d1) & RLC_MASK(3);
if (l0 % 2 == 0) {
u0 = 0;
} else {
u0 = 2 - (l0 & RLC_MASK(2));
if ((l0 == 3 || l0 == 5) && ((l1 & RLC_MASK(2)) == 2)) {
u0 = (int8_t)-u0;
}
}
jsf[i] = u0;
if (l1 % 2 == 0) {
u1 = 0;
} else {
u1 = 2 - (l1 & RLC_MASK(2));
if ((l1 == 3 || l1 == 5) && ((l0 & RLC_MASK(2)) == 2)) {
u1 = (int8_t)-u1;
}
}
jsf[i + offset] = u1;
if (d0 + d0 == 1 + u0) {
d0 = (int8_t)(1 - d0);
}
if (d1 + d1 == 1 + u1) {
d1 = (int8_t)(1 - d1);
}
i++;
bn_hlv(n0, n0);
bn_hlv(n1, n1);
}
*len = i;
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
bn_free(n0);
bn_free(n1);
}
} | Base | 1 |
void bn_rec_naf(int8_t *naf, int *len, const bn_t k, int w) {
int i, l;
bn_t t;
dig_t t0, mask;
int8_t u_i;
if (*len < (bn_bits(k) + 1)) {
*len = 0;
RLC_THROW(ERR_NO_BUFFER);
return;
}
bn_null(t);
RLC_TRY {
bn_new(t);
bn_abs(t, k);
mask = RLC_MASK(w);
l = (1 << w);
memset(naf, 0, *len);
i = 0;
if (w == 2) {
while (!bn_is_zero(t)) {
if (!bn_is_even(t)) {
bn_get_dig(&t0, t);
u_i = 2 - (t0 & mask);
if (u_i < 0) {
bn_add_dig(t, t, -u_i);
} else {
bn_sub_dig(t, t, u_i);
}
*naf = u_i;
} else {
*naf = 0;
}
bn_hlv(t, t);
i++;
naf++;
}
} else {
while (!bn_is_zero(t)) {
if (!bn_is_even(t)) {
bn_get_dig(&t0, t);
u_i = t0 & mask;
if (u_i > l / 2) {
u_i = (int8_t)(u_i - l);
}
if (u_i < 0) {
bn_add_dig(t, t, -u_i);
} else {
bn_sub_dig(t, t, u_i);
}
*naf = u_i;
} else {
*naf = 0;
}
bn_hlv(t, t);
i++;
naf++;
}
}
*len = i;
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
bn_free(t);
}
} | Base | 1 |
static char get_bits(const bn_t a, int from, int to) {
int f, t;
dig_t mf, mt;
RLC_RIP(from, f, from);
RLC_RIP(to, t, to);
if (f == t) {
/* Same digit. */
mf = RLC_MASK(from);
if (to + 1 >= RLC_DIG) {
mt = RLC_DMASK;
} else {
mt = RLC_MASK(to + 1);
}
mf = mf ^ mt;
return ((a->dp[f] & (mf)) >> from);
} else {
mf = RLC_MASK(RLC_DIG - from) << from;
mt = RLC_MASK(to + 1);
return ((a->dp[f] & mf) >> from) |
((a->dp[t] & mt) << (RLC_DIG - from));
}
} | Base | 1 |
void bn_rec_glv(bn_t k0, bn_t k1, const bn_t k, const bn_t n, const bn_t *v1,
const bn_t *v2) {
bn_t t, b1, b2;
int r1, r2, bits;
bn_null(b1);
bn_null(b2);
bn_null(t);
RLC_TRY {
bn_new(b1);
bn_new(b2);
bn_new(t);
bn_abs(t, k);
bits = bn_bits(n);
bn_mul(b1, t, v1[0]);
r1 = bn_get_bit(b1, bits);
bn_rsh(b1, b1, bits + 1);
bn_add_dig(b1, b1, r1);
bn_mul(b2, t, v2[0]);
r2 = bn_get_bit(b2, bits);
bn_rsh(b2, b2, bits + 1);
bn_add_dig(b2, b2, r2);
bn_mul(k0, b1, v1[1]);
bn_mul(k1, b2, v2[1]);
bn_add(k0, k0, k1);
bn_sub(k0, t, k0);
bn_mul(k1, b1, v1[2]);
bn_mul(t, b2, v2[2]);
bn_add(k1, k1, t);
bn_neg(k1, k1);
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
bn_free(b1);
bn_free(b2);
bn_free(t);
}
} | Base | 1 |
void bn_rec_reg(int8_t *naf, int *len, const bn_t k, int n, int w) {
int i, l;
bn_t t;
dig_t t0, mask;
int8_t u_i;
bn_null(t);
mask = RLC_MASK(w);
l = RLC_CEIL(n, w - 1);
if (*len <= l) {
*len = 0;
RLC_THROW(ERR_NO_BUFFER);
return;
}
RLC_TRY {
bn_new(t);
bn_abs(t, k);
memset(naf, 0, *len);
i = 0;
if (w == 2) {
for (i = 0; i < l; i++) {
u_i = (t->dp[0] & mask) - 2;
t->dp[0] -= u_i;
naf[i] = u_i;
bn_hlv(t, t);
}
bn_get_dig(&t0, t);
naf[i] = t0;
} else {
for (i = 0; i < l; i++) {
u_i = (t->dp[0] & mask) - (1 << (w - 1));
t->dp[0] -= u_i;
naf[i] = u_i;
bn_rsh(t, t, w - 1);
}
bn_get_dig(&t0, t);
naf[i] = t0;
}
*len = l + 1;
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
bn_free(t);
}
} | Base | 1 |
void bn_rec_tnaf_mod(bn_t r0, bn_t r1, const bn_t k, int u, int m) {
bn_t t, t0, t1, t2, t3;
bn_null(t);
bn_null(t0);
bn_null(t1);
bn_null(t2);
bn_null(t3);
RLC_TRY {
bn_new(t);
bn_new(t0);
bn_new(t1);
bn_new(t2);
bn_new(t3);
/* (a0, a1) = (1, 0). */
bn_set_dig(t0, 1);
bn_zero(t1);
/* (b0, b1) = (0, 0). */
bn_zero(t2);
bn_zero(t3);
/* (r0, r1) = (k, 0). */
bn_abs(r0, k);
bn_zero(r1);
for (int i = 0; i < m; i++) {
if (!bn_is_even(r0)) {
/* r0 = r0 - 1. */
bn_sub_dig(r0, r0, 1);
/* (b0, b1) = (b0 + a0, b1 + a1). */
bn_add(t2, t2, t0);
bn_add(t3, t3, t1);
}
bn_hlv(t, r0);
/* r0 = r1 + mu * r0 / 2. */
if (u == -1) {
bn_sub(r0, r1, t);
} else {
bn_add(r0, r1, t);
}
/* r1 = - r0 / 2. */
bn_neg(r1, t);
bn_dbl(t, t1);
/* a1 = a0 + mu * a1. */
if (u == -1) {
bn_sub(t1, t0, t1);
} else {
bn_add(t1, t0, t1);
}
/* a0 = - 2 * a1. */
bn_neg(t0, t);
}
/*r 0 = r0 + b0, r1 = r1 + b1. */
bn_add(r0, r0, t2);
bn_add(r1, r1, t3);
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
bn_free(t);
bn_free(t0);
bn_free(t1);
bn_free(t2);
bn_free(t3);
}
} | Base | 1 |
void bn_rec_win(uint8_t *win, int *len, const bn_t k, int w) {
int i, j, l;
l = bn_bits(k);
if (*len < RLC_CEIL(l, w)) {
*len = 0;
RLC_THROW(ERR_NO_BUFFER);
return;
}
memset(win, 0, *len);
j = 0;
for (i = 0; i < l - w; i += w) {
win[j++] = get_bits(k, i, i + w - 1);
}
win[j++] = get_bits(k, i, bn_bits(k) - 1);
*len = j;
} | Base | 1 |
void bn_rec_slw(uint8_t *win, int *len, const bn_t k, int w) {
int i, j, l, s;
l = bn_bits(k);
if (*len < l) {
*len = 0;
RLC_THROW(ERR_NO_BUFFER);
return;
}
memset(win, 0, *len);
i = l - 1;
j = 0;
while (i >= 0) {
if (!bn_get_bit(k, i)) {
i--;
win[j++] = 0;
} else {
s = RLC_MAX(i - w + 1, 0);
while (!bn_get_bit(k, s)) {
s++;
}
win[j++] = get_bits(k, s, i);
i = s - 1;
}
}
*len = j;
} | Base | 1 |
void bn_rsh(bn_t c, const bn_t a, int bits) {
int digits = 0;
bn_copy(c, a);
if (bits <= 0) {
return;
}
RLC_RIP(bits, digits, bits);
if (digits > 0) {
dv_rshd(c->dp, a->dp, a->used, digits);
}
c->used = a->used - digits;
c->sign = a->sign;
if (c->used > 0 && bits > 0) {
if (digits == 0 && c != a) {
bn_rshb_low(c->dp, a->dp + digits, a->used - digits, bits);
} else {
bn_rshb_low(c->dp, c->dp, c->used, bits);
}
}
bn_trim(c);
} | Base | 1 |
void bn_lsh(bn_t c, const bn_t a, int bits) {
int digits;
dig_t carry;
bn_copy(c, a);
if (bits <= 0) {
return;
}
RLC_RIP(bits, digits, bits);
RLC_TRY {
bn_grow(c, c->used + digits + (bits > 0));
c->used = a->used + digits;
c->sign = a->sign;
if (digits > 0) {
dv_lshd(c->dp, a->dp, c->used, digits);
}
if (bits > 0) {
if (c != a) {
carry = bn_lshb_low(c->dp + digits, a->dp, a->used, bits);
} else {
carry = bn_lshb_low(c->dp + digits, c->dp + digits, c->used - digits, bits);
}
if (carry != 0) {
c->dp[c->used] = carry;
(c->used)++;
}
}
bn_trim(c);
} RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
} | Base | 1 |
int bn_smb_jac(const bn_t a, const bn_t b) {
bn_t t0, t1, r;
int t, h, res;
bn_null(t0);
bn_null(t1);
bn_null(r);
/* Argument b must be odd. */
if (bn_is_even(b) || bn_sign(b) == RLC_NEG) {
RLC_THROW(ERR_NO_VALID);
return 0;
}
RLC_TRY {
bn_new(t0);
bn_new(t1);
bn_new(r);
t = 1;
if (bn_sign(a) == RLC_NEG) {
bn_add(t0, a, b);
} else {
bn_copy(t0, a);
}
bn_copy(t1, b);
while (1) {
/* t0 = a mod b. */
bn_mod(t0, t0, t1);
/* If a = 0 then if n = 1 return t else return 0. */
if (bn_is_zero(t0)) {
if (bn_cmp_dig(t1, 1) == RLC_EQ) {
res = 1;
if (t == -1) {
res = -1;
}
break;
} else {
res = 0;
break;
}
}
/* Write t0 as 2^h * t0. */
h = 0;
while (bn_is_even(t0)) {
h++;
bn_rsh(t0, t0, 1);
}
/* If h != 0 (mod 2) and n != +-1 (mod 8) then t = -t. */
bn_mod_2b(r, t1, 3);
if ((h % 2 != 0) && (bn_cmp_dig(r, 1) != RLC_EQ) &&
(bn_cmp_dig(r, 7) != RLC_EQ)) {
t = -t;
}
/* If t0 != 1 (mod 4) and n != 1 (mod 4) then t = -t. */
bn_mod_2b(r, t0, 2);
if (bn_cmp_dig(r, 1) != RLC_EQ) {
bn_mod_2b(r, t1, 2);
if (bn_cmp_dig(r, 1) != RLC_EQ) {
t = -t;
}
}
bn_copy(r, t0);
bn_copy(t0, t1);
bn_copy(t1, r);
}
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
bn_free(t0);
bn_free(t1);
bn_free(r);
}
return res;
} | Base | 1 |
void bn_srt(bn_t c, bn_t a) {
bn_t h, l, m, t;
int bits, cmp;
if (bn_sign(a) == RLC_NEG) {
RLC_THROW(ERR_NO_VALID);
}
bits = bn_bits(a);
bits += (bits % 2);
bn_null(h);
bn_null(l);
bn_null(m);
bn_null(t);
RLC_TRY {
bn_new(h);
bn_new(l);
bn_new(m);
bn_new(t);
bn_set_2b(h, bits >> 1);
bn_set_2b(l, (bits >> 1) - 1);
/* Trivial binary search approach. */
do {
bn_add(m, h, l);
bn_hlv(m, m);
bn_sqr(t, m);
cmp = bn_cmp(t, a);
bn_sub(t, h, l);
if (cmp == RLC_GT) {
bn_copy(h, m);
} else if (cmp == RLC_LT) {
bn_copy(l, m);
}
} while (bn_cmp_dig(t, 1) == RLC_GT && cmp != RLC_EQ);
bn_copy(c, m);
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
bn_free(h);
bn_free(l);
bn_free(m);
bn_free(t);
}
} | Base | 1 |
int bn_bits(const bn_t a) {
int bits;
if (bn_is_zero(a)) {
return 0;
}
/* Bits in lower digits. */
bits = (a->used - 1) * RLC_DIG;
return bits + util_bits_dig(a->dp[a->used - 1]);
} | Base | 1 |
void bn_write_raw(dig_t *raw, int len, const bn_t a) {
int i, size;
size = a->used;
if (len < size) {
RLC_THROW(ERR_NO_BUFFER);
return;
}
for (i = 0; i < size; i++) {
raw[i] = a->dp[i];
}
for (; i < len; i++) {
raw[i] = 0;
}
} | Base | 1 |
void bn_set_bit(bn_t a, int bit, int value) {
int d;
if (bit < 0) {
RLC_THROW(ERR_NO_VALID);
return;
}
RLC_RIP(bit, d, bit);
bn_grow(a, d);
if (value == 1) {
a->dp[d] |= ((dig_t)1 << bit);
if ((d + 1) > a->used) {
a->used = d + 1;
}
} else {
a->dp[d] &= ~((dig_t)1 << bit);
bn_trim(a);
}
} | Base | 1 |
void bn_write_bin(uint8_t *bin, int len, const bn_t a) {
int size, k;
dig_t d;
size = bn_size_bin(a);
if (len < size) {
RLC_THROW(ERR_NO_BUFFER);
return;
}
k = 0;
for (int i = 0; i < a->used - 1; i++) {
d = a->dp[i];
for (int j = 0; j < (int)(RLC_DIG / 8); j++) {
bin[len - 1 - k++] = d & 0xFF;
d = d >> 8;
}
}
d = a->dp[a->used - 1];
while (d != 0) {
bin[len - 1 - k++] = d & 0xFF;
d = d >> 8;
}
while (k < len) {
bin[len - 1 - k++] = 0;
}
} | Base | 1 |
int bn_size_raw(const bn_t a) {
return a->used;
} | Base | 1 |
int bn_size_str(const bn_t a, int radix) {
int digits = 0;
bn_t t;
bn_null(t);
/* Check the radix. */
if (radix < 2 || radix > 64) {
RLC_THROW(ERR_NO_VALID);
return 0;
}
if (bn_is_zero(a)) {
return 2;
}
/* Binary case requires the bits, a sign and the null terminator. */
if (radix == 2) {
return bn_bits(a) + (a->sign == RLC_NEG ? 1 : 0) + 1;
}
if (a->sign == RLC_NEG) {
digits++;
}
RLC_TRY {
bn_new(t);
bn_copy(t, a);
t->sign = RLC_POS;
while (!bn_is_zero(t)) {
bn_div_dig(t, t, (dig_t)radix);
digits++;
}
} RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
} RLC_FINALLY {
bn_free(t);
}
return digits + 1;
} | Base | 1 |
void bn_read_str(bn_t a, const char *str, int len, int radix) {
int sign, i, j;
char c;
bn_zero(a);
if (radix < 2 || radix > 64) {
RLC_THROW(ERR_NO_VALID);
return;
}
j = 0;
if (str[0] == '-') {
j++;
sign = RLC_NEG;
} else {
sign = RLC_POS;
}
RLC_TRY {
bn_grow(a, RLC_CEIL(len * util_bits_dig(radix), RLC_DIG));
while (j < len) {
if (str[j] == 0) {
break;
}
c = (char)((radix < 36) ? RLC_UPP(str[j]) : str[j]);
for (i = 0; i < 64; i++) {
if (c == util_conv_char(i)) {
break;
}
}
if (i < radix) {
bn_mul_dig(a, a, (dig_t)radix);
bn_add_dig(a, a, (dig_t)i);
} else {
break;
}
j++;
}
a->sign = sign;
bn_trim(a);
} RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
} | Base | 1 |
int bn_ham(const bn_t a) {
int c = 0;
for (int i = 0; i < bn_bits(a); i++) {
c += bn_get_bit(a, i);
}
return c;
} | Base | 1 |
void bn_set_2b(bn_t a, int b) {
int i, d;
if (b < 0) {
bn_zero(a);
} else {
RLC_RIP(b, d, b);
bn_grow(a, d + 1);
for (i = 0; i < d; i++) {
a->dp[i] = 0;
}
a->used = d + 1;
a->dp[d] = ((dig_t)1 << b);
a->sign = RLC_POS;
}
} | Base | 1 |
void bn_rand(bn_t a, int sign, int bits) {
int digits;
RLC_RIP(bits, digits, bits);
digits += (bits > 0 ? 1 : 0);
bn_grow(a, digits);
rand_bytes((uint8_t *)a->dp, digits * sizeof(dig_t));
a->used = digits;
a->sign = sign;
if (bits > 0) {
dig_t mask = ((dig_t)1 << (dig_t)bits) - 1;
a->dp[a->used - 1] &= mask;
}
bn_trim(a);
} | Base | 1 |
int bn_size_bin(const bn_t a) {
dig_t d;
int digits;
digits = (a->used - 1) * (RLC_DIG / 8);
d = a->dp[a->used - 1];
while (d != 0) {
d = d >> 8;
digits++;
}
return digits;
} | Base | 1 |
void bn_read_bin(bn_t a, const uint8_t *bin, int len) {
int i, j;
dig_t d = (RLC_DIG / 8);
int digs = (len % d == 0 ? len / d : len / d + 1);
bn_grow(a, digs);
bn_zero(a);
a->used = digs;
for (i = 0; i < digs - 1; i++) {
d = 0;
for (j = (RLC_DIG / 8) - 1; j >= 0; j--) {
d = d << 8;
d |= bin[len - 1 - (i * (RLC_DIG / 8) + j)];
}
a->dp[i] = d;
}
d = 0;
for (j = (RLC_DIG / 8) - 1; j >= 0; j--) {
if ((int)(i * (RLC_DIG / 8) + j) < len) {
d = d << 8;
d |= bin[len - 1 - (i * (RLC_DIG / 8) + j)];
}
}
a->dp[i] = d;
a->sign = RLC_POS;
bn_trim(a);
} | Base | 1 |
void bn_write_str(char *str, int len, const bn_t a, int radix) {
bn_t t;
dig_t d;
int digits, l, i, j;
char c;
bn_null(t);
l = bn_size_str(a, radix);
if (len < l) {
RLC_THROW(ERR_NO_BUFFER);
return;
}
if (radix < 2 || radix > 64) {
RLC_THROW(ERR_NO_VALID);
return;
}
if (bn_is_zero(a) == 1) {
*str++ = '0';
*str = '\0';
return;
}
RLC_TRY {
bn_new(t);
bn_copy(t, a);
j = 0;
if (t->sign == RLC_NEG) {
str[j] = '-';
j++;
t->sign = RLC_POS;
}
digits = 0;
while (!bn_is_zero(t) && j < len) {
bn_div_rem_dig(t, &d, t, (dig_t)radix);
str[j] = util_conv_char(d);
digits++;
j++;
}
/* Reverse the digits of the string. */
i = 0;
if (str[0] == '-') {
i = 1;
}
j = l - 2;
while (i < j) {
c = str[i];
str[i] = str[j];
str[j] = c;
++i;
--j;
}
str[l - 1] = '\0';
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
bn_free(t);
}
} | Base | 1 |
void bn_read_raw(bn_t a, const dig_t *raw, int len) {
RLC_TRY {
bn_grow(a, len);
a->used = len;
a->sign = RLC_POS;
dv_copy(a->dp, raw, len);
bn_trim(a);
} RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
} | Base | 1 |
int bn_get_bit(const bn_t a, int bit) {
int d;
if (bit < 0) {
RLC_THROW(ERR_NO_VALID);
return 0;
}
if (bit > bn_bits(a)) {
return 0;
}
RLC_RIP(bit, d, bit);
if (d >= a->used) {
return 0;
} else {
return (a->dp[d] >> bit) & (dig_t)1;
}
} | Base | 1 |
int cp_bls_sig(g1_t s, const uint8_t *msg, int len, const bn_t d) {
g1_t p;
int result = RLC_OK;
g1_null(p);
RLC_TRY {
g1_new(p);
g1_map(p, msg, len);
g1_mul_key(s, p, d);
}
RLC_CATCH_ANY {
result = RLC_ERR;
}
RLC_FINALLY {
g1_free(p);
}
return result;
} | Base | 1 |
int cp_cmlhs_sig(g1_t sig, g2_t z, g1_t a, g1_t c, g1_t r, g2_t s,
const bn_t msg, const char *data, int label, const bn_t x, const g1_t h,
const uint8_t prf[], size_t plen, const bn_t d, const bn_t sk,
int bls) {
bn_t k, m, n;
g1_t t;
uint8_t mac[RLC_MD_LEN];
int len, dlen = strlen(data), result = RLC_OK;
uint8_t *buf = RLC_ALLOCA(uint8_t, 1 + 8 * RLC_PC_BYTES + dlen);
bn_null(k);
bn_null(m);
bn_null(n);
g1_null(t);
RLC_TRY {
bn_new(k);
bn_new(m);
bn_new(n);
g1_new(t);
if (buf == NULL) {
RLC_THROW(ERR_NO_MEMORY);
}
pc_get_ord(n);
/* Generate r and s. */
bn_rand_mod(k, n);
bn_rand_mod(m, n);
/* Compute S = -g2^s, C = g1^s. */
g2_mul_gen(s, m);
g2_neg(s, s);
g1_mul_gen(c, m);
/* Compute R = g1^(r - ys). */
bn_mul(m, d, m);
bn_mod(m, m, n);
bn_sub(m, k, m);
bn_mod(m, m, n);
g1_mul_gen(r, m);
/* Compute A = g1^(x + r) * \prod H_j^(y * m_j). */
bn_add(k, x, k);
bn_mod(k, k, n);
g1_mul_gen(a, k);
bn_mul(k, d, msg);
bn_mod(k, k, n);
g1_mul(t, h, k);
g1_add(a, a, t);
g1_norm(a, a);
/* Compute z = F_K(delta), Z = g2^z, A = A^(1/z). */
md_hmac(mac, (const uint8_t *)data, dlen, prf, plen);
bn_read_bin(k, mac, RLC_MD_LEN);
bn_mod(k, k, n);
g2_mul_gen(z, k);
bn_mod_inv(k, k, n);
g1_mul(a, a, k);
/* Compute C = C * sum H_j^m_j. */
bn_mod(k, msg, n);
g1_mul(t, h, k);
g1_add(c, c, t);
g1_norm(c, c);
len = g2_size_bin(z, 0);
g2_write_bin(buf, len, z, 0);
memcpy(buf + len, data, dlen);
if (bls) {
cp_bls_sig(sig, buf, len + dlen, sk);
} else {
cp_ecdsa_sig(m, n, buf, len + dlen, 0, sk);
fp_prime_conv(sig->x, m);
fp_prime_conv(sig->y, n);
fp_set_dig(sig->z, 1);
}
}
RLC_CATCH_ANY {
result = RLC_ERR;
}
RLC_FINALLY {
bn_free(k);
bn_free(m);
bn_free(n);
g1_free(t);
RLC_FREE(buf);
}
return result;
} | Base | 1 |
int cp_cmlhs_ver(const g1_t r, const g2_t s, const g1_t sig[], const g2_t z[],
const g1_t a[], const g1_t c[], const bn_t msg, const char *data,
const g1_t h, const int label[], const gt_t *hs[], const dig_t *f[],
const size_t flen[], const g2_t y[], const g2_t pk[], size_t slen,
int bls) {
g1_t g1;
g2_t g2;
gt_t e, u, v;
bn_t k, n;
int len, dlen = strlen(data), result = 1;
uint8_t *buf = RLC_ALLOCA(uint8_t, 1 + 8 * RLC_PC_BYTES + dlen);
g1_null(g1);
g2_null(g2);
gt_null(e);
gt_null(u);
gt_null(v);
bn_null(k);
bn_null(n);
RLC_TRY {
g1_new(g1);
g2_new(g2);
gt_new(e);
gt_new(u);
gt_new(v);
bn_new(k);
bn_new(n);
if (buf == NULL) {
RLC_THROW(ERR_NO_MEMORY);
}
for (int i = 0; i < slen; i++) {
len = g2_size_bin(z[i], 0);
g2_write_bin(buf, len, z[i], 0);
memcpy(buf + len, data, dlen);
if (bls) {
result &= cp_bls_ver(sig[i], buf, len + dlen, pk[i]);
} else {
fp_prime_back(k, sig[i]->x);
fp_prime_back(n, sig[i]->y);
fp_copy(g1->x, pk[i]->x[0]);
fp_copy(g1->y, pk[i]->y[0]);
fp_set_dig(g1->z, 1);
result &= cp_ecdsa_ver(k, n, buf, len + dlen, 0, g1);
}
}
pc_get_ord(n);
g1_get_gen(g1);
g2_get_gen(g2);
pc_map_sim(e, a, z, slen);
pc_map_sim(u, c, y, slen);
pc_map(v, r, g2);
gt_mul(u, u, v);
for (int i = 0; i < slen; i++) {
for (int j = 0; j < flen[i]; j++) {
gt_exp_dig(v, hs[i][label[j]], f[i][j]);
gt_mul(u, u, v);
}
}
if (gt_cmp(e, u) != RLC_EQ) {
result = 0;
}
pc_map(e, g1, s);
g1_set_infty(g1);
for (int i = 0; i < slen; i++) {
g1_add(g1, g1, c[i]);
}
g1_norm(g1, g1);
pc_map(u, g1, g2);
gt_mul(e, e, u);
g1_mul(g1, h, msg);
pc_map(v, g1, g2);
if (gt_cmp(e, v) != RLC_EQ) {
result = 0;
}
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
g1_free(g1);
g2_free(g2);
gt_free(e);
gt_free(u);
gt_free(v);
bn_free(k);
bn_free(n);
RLC_FREE(buf);
}
return result;
} | Base | 1 |
int cp_cmlhs_gen(bn_t x[], gt_t hs[], size_t len, uint8_t prf[], size_t plen,
bn_t sk, g2_t pk, bn_t d, g2_t y, int bls) {
g1_t g1;
g2_t g2;
gt_t gt;
bn_t n;
int result = RLC_OK;
g1_null(g1);
g2_null(g2);
gt_null(gt);
bn_null(n);
RLC_TRY {
bn_new(n);
g1_new(g1);
g2_new(g2);
gt_new(gt);
pc_get_ord(n);
g1_get_gen(g1);
g2_get_gen(g2);
pc_map(gt, g1, g2);
rand_bytes(prf, plen);
if (bls) {
cp_bls_gen(sk, pk);
} else {
cp_ecdsa_gen(sk, g1);
fp_copy(pk->x[0], g1->x);
fp_copy(pk->y[0], g1->y);
}
/* Generate elements for n tags. */
for (int i = 0; i < len; i++) {
bn_rand_mod(x[i], n);
gt_exp(hs[i], gt, x[i]);
}
bn_rand_mod(d, n);
g2_mul_gen(y, d);
}
RLC_CATCH_ANY {
result = RLC_ERR;
}
RLC_FINALLY {
g1_free(g1);
g2_free(g2);
gt_free(gt);
bn_free(n);
}
return result;
} | Base | 1 |
int cp_cmlhs_onv(const g1_t r, const g2_t s, const g1_t sig[], const g2_t z[],
const g1_t a[], const g1_t c[], const bn_t msg, const char *data,
const g1_t h, const gt_t vk, const g2_t y[], const g2_t pk[],
size_t slen, int bls) {
g1_t g1;
g2_t g2;
gt_t e, u, v;
bn_t k, n;
int len, dlen = strlen(data), result = 1;
uint8_t *buf = RLC_ALLOCA(uint8_t, 1 + 8 * RLC_FP_BYTES + dlen);
g1_null(g1);
g2_null(g2);
gt_null(e);
gt_null(u);
gt_null(v);
bn_null(k);
bn_null(n);
RLC_TRY {
g1_new(g1);
g2_new(g2);
gt_new(e);
gt_new(u);
gt_new(v);
bn_new(k);
bn_new(n);
if (buf == NULL) {
RLC_THROW(ERR_NO_MEMORY);
}
for (int i = 0; i < slen; i++) {
len = g2_size_bin(z[i], 0);
g2_write_bin(buf, len, z[i], 0);
memcpy(buf + len, data, dlen);
if (bls) {
result &= cp_bls_ver(sig[i], buf, len + dlen, pk[i]);
} else {
fp_prime_back(k, sig[i]->x);
fp_prime_back(n, sig[i]->y);
fp_copy(g1->x, pk[i]->x[0]);
fp_copy(g1->y, pk[i]->y[0]);
fp_set_dig(g1->z, 1);
result &= cp_ecdsa_ver(k, n, buf, len + dlen, 0, g1);
}
}
pc_get_ord(n);
g1_get_gen(g1);
g2_get_gen(g2);
pc_map_sim(e, a, z, slen);
pc_map_sim(u, c, y, slen);
pc_map(v, r, g2);
gt_mul(u, u, v);
gt_mul(u, u, vk);
if (gt_cmp(e, u) != RLC_EQ) {
result = 0;
}
pc_map(e, g1, s);
g1_set_infty(g1);
for (int i = 0; i < slen; i++) {
g1_add(g1, g1, c[i]);
}
g1_norm(g1, g1);
pc_map(u, g1, g2);
gt_mul(e, e, u);
g1_mul(g1, h, msg);
pc_map(v, g1, g2);
if (gt_cmp(e, v) != RLC_EQ) {
result = 0;
}
} RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
} RLC_FINALLY {
g1_free(g1);
g2_free(g2);
gt_free(e);
gt_free(u);
gt_free(v);
bn_free(k);
bn_free(n);
RLC_FREE(buf);
}
return result;
} | Base | 1 |
int cp_rsa_gen(rsa_t pub, rsa_t prv, int bits) {
bn_t t, r;
int result = RLC_OK;
if (pub == NULL || prv == NULL || bits == 0) {
return RLC_ERR;
}
bn_null(t);
bn_null(r);
RLC_TRY {
bn_new(t);
bn_new(r);
/* Generate different primes p and q. */
do {
bn_gen_prime(prv->crt->p, bits / 2);
bn_gen_prime(prv->crt->q, bits / 2);
} while (bn_cmp(prv->crt->p, prv->crt->q) == RLC_EQ);
/* Swap p and q so that p is smaller. */
if (bn_cmp(prv->crt->p, prv->crt->q) != RLC_LT) {
bn_copy(t, prv->crt->p);
bn_copy(prv->crt->p, prv->crt->q);
bn_copy(prv->crt->q, t);
}
/* n = pq. */
bn_mul(pub->crt->n, prv->crt->p, prv->crt->q);
bn_copy(prv->crt->n, pub->crt->n);
bn_sub_dig(prv->crt->p, prv->crt->p, 1);
bn_sub_dig(prv->crt->q, prv->crt->q, 1);
/* phi(n) = (p - 1)(q - 1). */
bn_mul(t, prv->crt->p, prv->crt->q);
bn_set_2b(pub->e, 16);
bn_add_dig(pub->e, pub->e, 1);
#if !defined(CP_CRT)
/* d = e^(-1) mod phi(n). */
bn_gcd_ext(r, prv->d, NULL, pub->e, t);
if (bn_sign(prv->d) == RLC_NEG) {
bn_add(prv->d, prv->d, t);
}
if (bn_cmp_dig(r, 1) == RLC_EQ) {
/* Restore p and q. */
bn_add_dig(prv->crt->p, prv->crt->p, 1);
bn_add_dig(prv->crt->q, prv->crt->q, 1);
result = RLC_OK;
}
#else
/* d = e^(-1) mod phi(n). */
bn_gcd_ext(r, prv->d, NULL, pub->e, t);
if (bn_sign(prv->d) == RLC_NEG) {
bn_add(prv->d, prv->d, t);
}
if (bn_cmp_dig(r, 1) == RLC_EQ) {
/* dP = d mod (p - 1). */
bn_mod(prv->crt->dp, prv->d, prv->crt->p);
/* dQ = d mod (q - 1). */
bn_mod(prv->crt->dq, prv->d, prv->crt->q);
/* Restore p and q. */
bn_add_dig(prv->crt->p, prv->crt->p, 1);
bn_add_dig(prv->crt->q, prv->crt->q, 1);
/* qInv = q^(-1) mod p. */
bn_mod_inv(prv->crt->qi, prv->crt->q, prv->crt->p);
result = RLC_OK;
}
#endif /* CP_CRT */
}
RLC_CATCH_ANY {
result = RLC_ERR;
}
RLC_FINALLY {
bn_free(t);
bn_free(r);
}
return result;
} | Base | 1 |
int cp_sokaka_key(uint8_t *key, size_t key_len, const char *id1,
const sokaka_t k, const char *id2) {
int len1 = strlen(id1), len2 = strlen(id2);
int size, first = 0, result = RLC_OK;
uint8_t *buf;
g1_t p;
g2_t q;
gt_t e;
g1_null(p);
g2_null(q);
gt_null(e);
RLC_TRY {
g1_new(p);
g2_new(q);
gt_new(e);
size = gt_size_bin(e, 0);
buf = RLC_ALLOCA(uint8_t, size);
if (buf == NULL) {
RLC_THROW(ERR_NO_MEMORY);
}
if (len1 == len2) {
if (strncmp(id1, id2, len1) == 0) {
RLC_THROW(ERR_NO_VALID);
}
first = (strncmp(id1, id2, len1) < 0 ? 1 : 2);
} else {
if (len1 < len2) {
if (strncmp(id1, id2, len1) == 0) {
first = 1;
} else {
first = (strncmp(id1, id2, len1) < 0 ? 1 : 2);
}
} else {
if (strncmp(id1, id2, len2) == 0) {
first = 2;
} else {
first = (strncmp(id1, id2, len2) < 0 ? 1 : 2);
}
}
}
if (pc_map_is_type1()) {
g2_map(q, (uint8_t *)id2, len2);
pc_map(e, k->s1, q);
} else {
if (first == 1) {
g2_map(q, (uint8_t *)id2, len2);
pc_map(e, k->s1, q);
} else {
g1_map(p, (uint8_t *)id2, len2);
pc_map(e, p, k->s2);
}
}
/* Allocate size for storing the output. */
gt_write_bin(buf, size, e, 0);
md_kdf(key, key_len, buf, size);
}
RLC_CATCH_ANY {
result = RLC_ERR;
}
RLC_FINALLY {
g1_free(p);
g2_free(q);
gt_free(e);
RLC_FREE(buf);
}
return result;
} | Base | 1 |
int cp_vbnn_gen_prv(bn_t sk, ec_t pk, const bn_t msk, const uint8_t *id,
size_t id_len) {
uint8_t hash[RLC_MD_LEN];
int len, result = RLC_OK;
uint8_t *buf = NULL;
bn_t n, r;
/* zero variables */
bn_null(n);
bn_null(r);
RLC_TRY {
/* initialize variables */
bn_new(n);
bn_new(r);
/* get order of ECC group */
ec_curve_get_ord(n);
/* extract user key from id */
bn_rand_mod(r, n);
/* calculate R part of the user key */
ec_mul_gen(pk, r);
/* calculate s part of the user key */
len = id_len + ec_size_bin(pk, 1);
buf = RLC_ALLOCA(uint8_t, len);
if (buf == NULL) {
RLC_THROW(ERR_NO_MEMORY);
}
memcpy(buf, id, id_len);
ec_write_bin(buf + id_len, ec_size_bin(pk, 1), pk, 1);
md_map(hash, buf, len);
bn_read_bin(sk, hash, RLC_MD_LEN);
bn_mod(sk, sk, n);
bn_mul(sk, sk, msk);
bn_add(sk, sk, r);
bn_mod(sk, sk, n);
}
RLC_CATCH_ANY {
result = RLC_ERR;
}
RLC_FINALLY {
/* free variables */
bn_free(n);
bn_free(r);
RLC_FREE(buf);
}
return result;
} | Base | 1 |
int cp_vbnn_sig(ec_t r, bn_t z, bn_t h, const uint8_t *id, size_t id_len,
const uint8_t *msg, int msg_len, const bn_t sk, const ec_t pk) {
int len, result = RLC_OK;
uint8_t *buf = NULL, *buf_i, hash[RLC_MD_LEN];
bn_t n, y;
ec_t t;
/* zero variables */
bn_null(n);
bn_null(y);
ec_null(t);
RLC_TRY {
bn_new(n);
bn_new(y);
ec_new(t);
/* get order of ECC group */
ec_curve_get_ord(n);
bn_rand_mod(y, n);
ec_mul_gen(t, y);
/* calculate h part of the signature */
len = id_len + msg_len + ec_size_bin(t, 1) + ec_size_bin(pk, 1);
buf = RLC_ALLOCA(uint8_t, len);
if (buf == NULL) {
RLC_THROW(ERR_NO_MEMORY);
}
buf_i = buf;
memcpy(buf_i, id, id_len);
buf_i += id_len;
memcpy(buf_i, msg, msg_len);
buf_i += msg_len;
ec_write_bin(buf_i, ec_size_bin(pk, 1), pk, 1);
buf_i += ec_size_bin(pk, 1);
ec_write_bin(buf_i, ec_size_bin(t, 1), t, 1);
md_map(hash, buf, len);
bn_read_bin(h, hash, RLC_MD_LEN);
bn_mod(h, h, n);
/* calculate z part of the signature */
bn_mul(z, h, sk);
bn_add(z, z, y);
bn_mod(z, z, n);
/* calculate R part of the signature */
ec_copy(r, pk);
}
RLC_CATCH_ANY {
result = RLC_ERR;
}
RLC_FINALLY {
/* free variables */
bn_free(n);
bn_free(y);
ec_free(t);
RLC_FREE(buf);
}
return result;
} | Base | 1 |
int cp_vbnn_ver(const ec_t r, const bn_t z, const bn_t h, const uint8_t *id,
size_t id_len, const uint8_t *msg, int msg_len, const ec_t mpk) {
int len, result = 0;
uint8_t *buf = NULL, *buf_i, hash[RLC_MD_LEN];
bn_t n, c, _h;
ec_t Z;
ec_t t;
/* zero variables */
bn_null(n);
bn_null(c);
bn_null(_h);
ec_null(Z);
ec_null(t);
RLC_TRY {
bn_new(n);
bn_new(c);
bn_new(_h);
ec_new(Z);
ec_new(t);
/* calculate c */
len = id_len + msg_len + 2 * ec_size_bin(r, 1);
buf = RLC_ALLOCA(uint8_t, len);
if (buf == NULL) {
RLC_THROW(ERR_NO_MEMORY);
}
/* get order of ECC group */
ec_curve_get_ord(n);
buf_i = buf;
memcpy(buf_i, id, id_len);
buf_i += id_len;
ec_write_bin(buf_i, ec_size_bin(r, 1), r, 1);
len = id_len + ec_size_bin(r, 1);
md_map(hash, buf, len);
bn_read_bin(c, hash, RLC_MD_LEN);
bn_mod(c, c, n);
/* calculate Z */
ec_mul_gen(Z, z);
ec_mul(t, mpk, c);
ec_add(t, t, r);
ec_norm(t, t);
ec_mul(t, t, h);
ec_sub(Z, Z, t);
ec_norm(Z, Z);
/* calculate h_verify */
buf_i = buf;
memcpy(buf_i, id, id_len);
buf_i += id_len;
memcpy(buf_i, msg, msg_len);
buf_i += msg_len;
ec_write_bin(buf_i, ec_size_bin(r, 1), r, 1);
buf_i += ec_size_bin(r, 1);
ec_write_bin(buf_i, ec_size_bin(Z, 1), Z, 1);
len = id_len + msg_len + ec_size_bin(r, 1) + ec_size_bin(Z, 1);
md_map(hash, buf, len);
bn_read_bin(_h, hash, RLC_MD_LEN);
bn_mod(_h, _h, n);
RLC_FREE(buf);
if (bn_cmp(h, _h) == RLC_EQ) {
result = 1;
} else {
result = 0;
}
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
/* free variables */
bn_free(n);
bn_free(c);
bn_free(_h);
ec_free(Z);
ec_free(t);
RLC_FREE(buf);
}
return result;
} | Base | 1 |
void eb_map(eb_t p, const uint8_t *msg, int len) {
bn_t k;
fb_t t0, t1;
int i;
uint8_t digest[RLC_MD_LEN];
bn_null(k);
fb_null(t0);
fb_null(t1);
RLC_TRY {
bn_new(k);
fb_new(t0);
fb_new(t1);
md_map(digest, msg, len);
bn_read_bin(k, digest, RLC_MIN(RLC_FB_BYTES, RLC_MD_LEN));
fb_set_dig(p->z, 1);
i = 0;
while (1) {
bn_add_dig(k, k, 1);
bn_mod_2b(k, k, RLC_FB_BITS);
dv_copy(p->x, k->dp, RLC_FB_DIGS);
eb_rhs(t1, p);
/* t0 = 1/x1^2. */
fb_sqr(t0, p->x);
fb_inv(t0, t0);
/* t0 = t1/x1^2. */
fb_mul(t0, t0, t1);
/* Solve t1^2 + t1 = t0. */
if (fb_trc(t0) != 0) {
i++;
} else {
fb_slv(t1, t0);
/* x3 = x1, y3 = t1 * x1, z3 = 1. */
fb_mul(p->y, t1, p->x);
fb_set_dig(p->z, 1);
p->coord = BASIC;
break;
}
}
/* Now, multiply by cofactor to get the correct group. */
eb_curve_get_cof(k);
if (bn_bits(k) < RLC_DIG) {
eb_mul_dig(p, p, k->dp[0]);
} else {
eb_mul(p, p, k);
}
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
bn_free(k);
fb_free(t0);
fb_free(t1);
}
} | Base | 1 |
static void eb_mul_lnaf_imp(eb_t r, const eb_t p, const bn_t k) {
int i, l, n;
int8_t naf[RLC_FB_BITS + 1];
eb_t t[1 << (EB_WIDTH - 2)];
RLC_TRY {
/* Prepare the precomputation table. */
for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
eb_null(t[i]);
eb_new(t[i]);
eb_set_infty(t[i]);
fb_set_dig(t[i]->z, 1);
t[i]->coord = BASIC;
}
/* Compute the precomputation table. */
eb_tab(t, p, EB_WIDTH);
/* Compute the w-NAF representation of k. */
l = sizeof(naf);
bn_rec_naf(naf, &l, k, EB_WIDTH);
n = naf[l - 1];
if (n > 0) {
eb_copy(r, t[n / 2]);
}
for (i = l - 2; i >= 0; i--) {
eb_dbl(r, r);
n = naf[i];
if (n > 0) {
eb_add(r, r, t[n / 2]);
}
if (n < 0) {
eb_sub(r, r, t[-n / 2]);
}
}
/* Convert r to affine coordinates. */
eb_norm(r, r);
if (bn_sign(k) == RLC_NEG) {
eb_neg(r, r);
}
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
/* Free the precomputation table. */
for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
eb_free(t[i]);
}
}
} | Base | 1 |
static void eb_mul_ltnaf_imp(eb_t r, const eb_t p, const bn_t k) {
int i, l, n;
int8_t tnaf[RLC_FB_BITS + 8], u;
eb_t t[1 << (EB_WIDTH - 2)];
if (eb_curve_opt_a() == RLC_ZERO) {
u = -1;
} else {
u = 1;
}
RLC_TRY {
/* Prepare the precomputation table. */
for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
eb_null(t[i]);
eb_new(t[i]);
}
/* Compute the precomputation table. */
eb_tab(t, p, EB_WIDTH);
/* Compute the w-TNAF representation of k. */
l = sizeof(tnaf);
bn_rec_tnaf(tnaf, &l, k, u, RLC_FB_BITS, EB_WIDTH);
n = tnaf[l - 1];
if (n > 0) {
eb_copy(r, t[n / 2]);
} else {
eb_neg(r, t[-n / 2]);
}
for (i = l - 2; i >= 0; i--) {
eb_frb(r, r);
n = tnaf[i];
if (n > 0) {
eb_add(r, r, t[n / 2]);
}
if (n < 0) {
eb_sub(r, r, t[-n / 2]);
}
}
/* Convert r to affine coordinates. */
eb_norm(r, r);
if (bn_sign(k) == RLC_NEG) {
eb_neg(r, r);
}
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
/* Free the precomputation table. */
for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
eb_free(t[i]);
}
}
} | Base | 1 |
void eb_mul_sim_joint(eb_t r, const eb_t p, const bn_t k, const eb_t q,
const bn_t m) {
eb_t t[5];
int i, u_i, len, offset;
int8_t jsf[2 * (RLC_FB_BITS + 1)];
if (bn_is_zero(k) || eb_is_infty(p)) {
eb_mul(r, q, m);
return;
}
if (bn_is_zero(m) || eb_is_infty(q)) {
eb_mul(r, p, k);
return;
}
RLC_TRY {
for (i = 0; i < 5; i++) {
eb_null(t[i]);
eb_new(t[i]);
}
eb_set_infty(t[0]);
eb_copy(t[1], q);
if (bn_sign(m) == RLC_NEG) {
eb_neg(t[1], t[1]);
}
eb_copy(t[2], p);
if (bn_sign(k) == RLC_NEG) {
eb_neg(t[2], t[2]);
}
eb_add(t[3], t[2], t[1]);
eb_sub(t[4], t[2], t[1]);
#if defined(EB_MIXED)
eb_norm_sim(t + 3, (const eb_t*)(t + 3), 2);
#endif
len = 2 * (RLC_FB_BITS + 1);
bn_rec_jsf(jsf, &len, k, m);
eb_set_infty(r);
offset = RLC_MAX(bn_bits(k), bn_bits(m)) + 1;
for (i = len - 1; i >= 0; i--) {
eb_dbl(r, r);
if (jsf[i] != 0 && jsf[i] == -jsf[i + offset]) {
u_i = jsf[i] * 2 + jsf[i + offset];
if (u_i < 0) {
eb_sub(r, r, t[4]);
} else {
eb_add(r, r, t[4]);
}
} else {
u_i = jsf[i] * 2 + jsf[i + offset];
if (u_i < 0) {
eb_sub(r, r, t[-u_i]);
} else {
eb_add(r, r, t[u_i]);
}
}
}
eb_norm(r, r);
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
for (i = 0; i < 5; i++) {
eb_free(t[i]);
}
}
} | Base | 1 |
void eb_mul_sim_trick(eb_t r, const eb_t p, const bn_t k, const eb_t q,
const bn_t m) {
eb_t t0[1 << (EB_WIDTH / 2)], t1[1 << (EB_WIDTH / 2)], t[1 << EB_WIDTH];
int l0, l1, w = EB_WIDTH / 2;
uint8_t w0[RLC_FB_BITS], w1[RLC_FB_BITS];
bn_t n;
bn_null(n);
if (bn_is_zero(k) || eb_is_infty(p)) {
eb_mul(r, q, m);
return;
}
if (bn_is_zero(m) || eb_is_infty(q)) {
eb_mul(r, p, k);
return;
}
RLC_TRY {
bn_new(n);
eb_curve_get_ord(n);
for (int i = 0; i < (1 << w); i++) {
eb_null(t0[i]);
eb_null(t1[i]);
eb_new(t0[i]);
eb_new(t1[i]);
}
for (int i = 0; i < (1 << EB_WIDTH); i++) {
eb_null(t[i]);
eb_new(t[i]);
}
eb_set_infty(t0[0]);
eb_copy(t0[1], p);
if (bn_sign(k) == RLC_NEG) {
eb_neg(t0[1], t0[1]);
}
for (int i = 2; i < (1 << w); i++) {
eb_add(t0[i], t0[i - 1], t0[1]);
}
eb_set_infty(t1[0]);
eb_copy(t1[1], q);
if (bn_sign(m) == RLC_NEG) {
eb_neg(t1[1], t1[1]);
}
for (int i = 2; i < (1 << w); i++) {
eb_add(t1[i], t1[i - 1], t1[1]);
}
for (int i = 0; i < (1 << w); i++) {
for (int j = 0; j < (1 << w); j++) {
eb_add(t[(i << w) + j], t0[i], t1[j]);
}
}
#if EB_WIDTH > 2 && defined(EB_MIXED)
eb_norm_sim(t + 1, (const eb_t *)(t + 1), (1 << EB_WIDTH) - 1);
#endif
l0 = l1 = RLC_CEIL(RLC_FB_BITS + 1, w);
bn_rec_win(w0, &l0, k, w);
bn_rec_win(w1, &l1, m, w);
for (int i = l0; i < l1; i++) {
w0[i] = 0;
}
for (int i = l1; i < l0; i++) {
w1[i] = 0;
}
eb_set_infty(r);
for (int i = RLC_MAX(l0, l1) - 1; i >= 0; i--) {
for (int j = 0; j < w; j++) {
eb_dbl(r, r);
}
eb_add(r, r, t[(w0[i] << w) + w1[i]]);
}
eb_norm(r, r);
} RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
bn_free(n);
for (int i = 0; i < (1 << w); i++) {
eb_free(t0[i]);
eb_free(t1[i]);
}
for (int i = 0; i < (1 << EB_WIDTH); i++) {
eb_free(t[i]);
}
}
} | Base | 1 |
static void eb_mul_sim_plain(eb_t r, const eb_t p, const bn_t k, const eb_t q,
const bn_t m, const eb_t *t) {
int i, l, l0, l1, n0, n1, w, g;
int8_t naf0[RLC_FB_BITS + 1], naf1[RLC_FB_BITS + 1], *_k, *_m;
eb_t t0[1 << (EB_WIDTH - 2)];
eb_t t1[1 << (EB_WIDTH - 2)];
for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
eb_null(t0[i]);
eb_null(t1[i]);
}
RLC_TRY {
g = (t == NULL ? 0 : 1);
if (!g) {
for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
eb_new(t0[i]);
}
eb_tab(t0, p, EB_WIDTH);
t = (const eb_t *)t0;
}
/* Prepare the precomputation table. */
for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
eb_new(t1[i]);
}
/* Compute the precomputation table. */
eb_tab(t1, q, EB_WIDTH);
/* Compute the w-NAF representation of k. */
if (g) {
w = EB_DEPTH;
} else {
w = EB_WIDTH;
}
l0 = l1 = RLC_FB_BITS + 1;
bn_rec_naf(naf0, &l0, k, w);
bn_rec_naf(naf1, &l1, m, EB_WIDTH);
l = RLC_MAX(l0, l1);
if (bn_sign(k) == RLC_NEG) {
for (i = 0; i < l0; i++) {
naf0[i] = -naf0[i];
}
}
if (bn_sign(m) == RLC_NEG) {
for (i = 0; i < l1; i++) {
naf1[i] = -naf1[i];
}
}
_k = naf0 + l - 1;
_m = naf1 + l - 1;
eb_set_infty(r);
for (i = l - 1; i >= 0; i--, _k--, _m--) {
eb_dbl(r, r);
n0 = *_k;
n1 = *_m;
if (n0 > 0) {
eb_add(r, r, t[n0 / 2]);
}
if (n0 < 0) {
eb_sub(r, r, t[-n0 / 2]);
}
if (n1 > 0) {
eb_add(r, r, t1[n1 / 2]);
}
if (n1 < 0) {
eb_sub(r, r, t1[-n1 / 2]);
}
}
/* Convert r to affine coordinates. */
eb_norm(r, r);
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
/* Free the precomputation tables. */
if (!g) {
for (i = 0; i < 1 << (EB_WIDTH - 2); i++) {
eb_free(t0[i]);
}
}
for (i = 0; i < 1 << (EB_WIDTH - 2); i++) {
eb_free(t1[i]);
}
}
} | Base | 1 |
void eb_read_bin(eb_t a, const uint8_t *bin, int len) {
if (len == 1) {
if (bin[0] == 0) {
eb_set_infty(a);
return;
} else {
RLC_THROW(ERR_NO_BUFFER);
return;
}
}
if (len != (RLC_FB_BYTES + 1) && len != (2 * RLC_FB_BYTES + 1)) {
RLC_THROW(ERR_NO_BUFFER);
return;
}
a->coord = BASIC;
fb_set_dig(a->z, 1);
fb_read_bin(a->x, bin + 1, RLC_FB_BYTES);
if (len == RLC_FB_BYTES + 1) {
switch(bin[0]) {
case 2:
fb_zero(a->y);
break;
case 3:
fb_zero(a->y);
fb_set_bit(a->y, 0, 1);
break;
default:
RLC_THROW(ERR_NO_VALID);
break;
}
eb_upk(a, a);
}
if (len == 2 * RLC_FB_BYTES + 1) {
if (bin[0] == 4) {
fb_read_bin(a->y, bin + RLC_FB_BYTES + 1, RLC_FB_BYTES);
} else {
RLC_THROW(ERR_NO_VALID);
return;
}
}
if (!eb_on_curve(a)) {
RLC_THROW(ERR_NO_VALID);
return;
}
} | Base | 1 |
void eb_write_bin(uint8_t *bin, int len, const eb_t a, int pack) {
eb_t t;
eb_null(t);
memset(bin, 0, len);
if (eb_is_infty(a)) {
if (len < 1) {
RLC_THROW(ERR_NO_BUFFER);
return;
} else {
return;
}
}
RLC_TRY {
eb_new(t);
eb_norm(t, a);
if (pack) {
if (len < RLC_FB_BYTES + 1) {
RLC_THROW(ERR_NO_BUFFER);
} else {
eb_pck(t, t);
bin[0] = 2 | fb_get_bit(t->y, 0);
fb_write_bin(bin + 1, RLC_FB_BYTES, t->x);
}
} else {
if (len < 2 * RLC_FB_BYTES + 1) {
RLC_THROW(ERR_NO_BUFFER);
} else {
bin[0] = 4;
fb_write_bin(bin + 1, RLC_FB_BYTES, t->x);
fb_write_bin(bin + RLC_FB_BYTES + 1, RLC_FB_BYTES, t->y);
}
}
} RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
eb_free(t);
}
} | Base | 1 |
void ed_map_dst(ed_t p, const uint8_t *msg, int len, const uint8_t *dst, int dst_len) {
bn_t k;
fp_t t;
ed_t q;
/* enough space for two field elements plus extra bytes for uniformity */
const int len_per_elm = (FP_PRIME + ed_param_level() + 7) / 8;
uint8_t *pseudo_random_bytes = RLC_ALLOCA(uint8_t, 2 * len_per_elm);
bn_null(k);
fp_null(t);
ed_null(q);
RLC_TRY {
bn_new(k);
fp_new(t);
ed_new(q);
/* pseudorandom string */
md_xmd(pseudo_random_bytes, 2 * len_per_elm, msg, len, dst, dst_len);
#define ED_MAP_CONVERT_BYTES(IDX) \
do { \
bn_read_bin(k, pseudo_random_bytes + IDX * len_per_elm, len_per_elm); \
fp_prime_conv(t, k); \
} while (0)
/* first map invocation */
ED_MAP_CONVERT_BYTES(0);
ed_map_ell2_5mod8(p, t);
/* second map invocation */
ED_MAP_CONVERT_BYTES(1);
ed_map_ell2_5mod8(q, t);
#undef ED_MAP_CONVERT_BYTES
ed_add(p, p, q);
/* clear cofactor */
switch (ed_param_get()) {
case CURVE_ED25519:
ed_dbl(p, p);
ed_dbl(p, p);
ed_dbl(p, p);
break;
default:
RLC_THROW(ERR_NO_VALID);
break;
}
ed_norm(p, p);
#if ED_ADD == EXTND
fp_mul(p->t, p->x, p->y);
#endif
p->coord = BASIC;
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
bn_free(k);
fp_free(t);
ed_free(q);
RLC_FREE(pseudo_random_bytes);
}
} | Base | 1 |
void ed_map(ed_t p, const uint8_t *msg, int len) {
ed_map_dst(p, msg, len, (const uint8_t *)"RELIC", 5);
} | Base | 1 |
static void ed_mul_reg_imp(ed_t r, const ed_t p, const bn_t k) {
bn_t _k;
int i, j, l, n;
int8_t s, reg[RLC_CEIL(RLC_FP_BITS + 1, ED_WIDTH - 1)];
ed_t t[1 << (ED_WIDTH - 2)], u, v;
bn_null(_k);
if (bn_is_zero(k)) {
ed_set_infty(r);
return;
}
RLC_TRY {
bn_new(_k);
ed_new(u);
ed_new(v);
/* Prepare the precomputation table. */
for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
ed_null(t[i]);
ed_new(t[i]);
}
/* Compute the precomputation table. */
ed_tab(t, p, ED_WIDTH);
/* Make a copy of the scalar for processing. */
bn_abs(_k, k);
_k->dp[0] |= bn_is_even(_k);
/* Compute the w-NAF representation of k. */
l = RLC_CEIL(RLC_FP_BITS + 1, ED_WIDTH - 1);
bn_rec_reg(reg, &l, _k, RLC_FP_BITS, ED_WIDTH);
ed_set_infty(r);
for (i = l - 1; i >= 0; i--) {
for (j = 0; j < ED_WIDTH - 1; j++) {
#if ED_ADD == EXTND
r->coord = EXTND;
#endif
ed_dbl(r, r);
}
n = reg[i];
s = (n >> 7);
n = ((n ^ s) - s) >> 1;
for (j = 0; j < (1 << (EP_WIDTH - 2)); j++) {
dv_copy_cond(u->x, t[j]->x, RLC_FP_DIGS, j == n);
dv_copy_cond(u->y, t[j]->y, RLC_FP_DIGS, j == n);
dv_copy_cond(u->z, t[j]->z, RLC_FP_DIGS, j == n);
}
ed_neg(v, u);
dv_copy_cond(u->x, v->x, RLC_FP_DIGS, s != 0);
ed_add(r, r, u);
}
/* t[0] has an unmodified copy of p. */
ed_sub(u, r, t[0]);
dv_copy_cond(r->x, u->x, RLC_FP_DIGS, bn_is_even(k));
dv_copy_cond(r->y, u->y, RLC_FP_DIGS, bn_is_even(k));
dv_copy_cond(r->z, u->z, RLC_FP_DIGS, bn_is_even(k));
/* Convert r to affine coordinates. */
ed_norm(r, r);
ed_neg(u, r);
dv_copy_cond(r->x, u->x, RLC_FP_DIGS, bn_sign(k) == RLC_NEG);
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
/* Free the precomputation table. */
for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
ed_free(t[i]);
}
bn_free(_k);
}
} | Base | 1 |
void ed_mul_slide(ed_t r, const ed_t p, const bn_t k) {
ed_t t[1 << (EP_WIDTH - 1)], q;
int i, j, l;
uint8_t win[RLC_FP_BITS + 1];
ed_null(q);
if (bn_is_zero(k) || ed_is_infty(p)) {
ed_set_infty(r);
return;
}
RLC_TRY {
for (i = 0; i < (1 << (EP_WIDTH - 1)); i ++) {
ed_null(t[i]);
ed_new(t[i]);
}
ed_new(q);
ed_copy(t[0], p);
ed_dbl(q, p);
#if defined(EP_MIXED)
ed_norm(q, q);
#endif
/* Create table. */
for (i = 1; i < (1 << (EP_WIDTH - 1)); i++) {
ed_add(t[i], t[i - 1], q);
}
#if defined(EP_MIXED)
ed_norm_sim(t + 1, (const ed_t *)t + 1, (1 << (EP_WIDTH - 1)) - 1);
#endif
ed_set_infty(q);
l = RLC_FP_BITS + 1;
bn_rec_slw(win, &l, k, EP_WIDTH);
for (i = 0; i < l; i++) {
if (win[i] == 0) {
ed_dbl(q, q);
} else {
for (j = 0; j < util_bits_dig(win[i]); j++) {
ed_dbl(q, q);
}
ed_add(q, q, t[win[i] >> 1]);
}
}
ed_norm(r, q);
if (bn_sign(k) == RLC_NEG) {
ed_neg(r, r);
}
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
for (i = 0; i < (1 << (EP_WIDTH - 1)); i++) {
ed_free(t[i]);
}
ed_free(q);
}
} | Base | 1 |
void ed_mul_dig(ed_t r, const ed_t p, dig_t k) {
ed_t t;
bn_t _k;
int8_t u, naf[RLC_DIG + 1];
int l;
ed_null(t);
bn_null(_k);
if (k == 0 || ed_is_infty(p)) {
ed_set_infty(r);
return;
}
RLC_TRY {
ed_new(t);
bn_new(_k);
bn_set_dig(_k, k);
l = RLC_DIG + 1;
bn_rec_naf(naf, &l, _k, 2);
ed_set_infty(t);
for (int i = l - 1; i >= 0; i--) {
ed_dbl(t, t);
u = naf[i];
if (u > 0) {
ed_add(t, t, p);
} else if (u < 0) {
ed_sub(t, t, p);
}
}
ed_norm(r, t);
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
ed_free(t);
bn_free(_k);
}
} | Base | 1 |
static void ed_mul_naf_imp(ed_t r, const ed_t p, const bn_t k) {
int l, i, n;
int8_t naf[RLC_FP_BITS + 1];
ed_t t[1 << (ED_WIDTH - 2)];
if (bn_is_zero(k)) {
ed_set_infty(r);
return;
}
RLC_TRY {
/* Prepare the precomputation table. */
for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
ed_null(t[i]);
ed_new(t[i]);
}
/* Compute the precomputation table. */
ed_tab(t, p, ED_WIDTH);
/* Compute the w-NAF representation of k. */
l = sizeof(naf);
bn_rec_naf(naf, &l, k, EP_WIDTH);
ed_set_infty(r);
for (i = l - 1; i > 0; i--) {
n = naf[i];
if (n == 0) {
/* This point will be doubled in the next iteration. */
#if ED_ADD == EXTND
r->coord = EXTND;
#endif
}
ed_dbl(r, r);
if (n > 0) {
ed_add(r, r, t[n / 2]);
} else if (n < 0) {
ed_sub(r, r, t[-n / 2]);
}
}
/* Last iteration. */
n = naf[0];
ed_dbl(r, r);
if (n > 0) {
ed_add(r, r, t[n / 2]);
} else if (n < 0) {
ed_sub(r, r, t[-n / 2]);
}
/* Convert r to affine coordinates. */
ed_norm(r, r);
if (bn_sign(k) == RLC_NEG) {
ed_neg(r, r);
}
}
RLC_CATCH_ANY {
RLC_THROW(ERR_CAUGHT);
}
RLC_FINALLY {
/* Free the precomputation table. */
for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
ed_free(t[i]);
}
}
} | Base | 1 |
static void ed_mul_fix_plain(ed_t r, const ed_t * t, const bn_t k) {
int l, i, n;
int8_t naf[RLC_FP_BITS + 1], *_k;
/* Compute the w-TNAF representation of k. */
l = RLC_FP_BITS + 1;
bn_rec_naf(naf, &l, k, ED_DEPTH);
_k = naf + l - 1;
ed_set_infty(r);
for (i = l - 1; i >= 0; i--, _k--) {
n = *_k;
if (n == 0) {
/* doubling is followed by another doubling */
if (i > 0) {
r->coord = EXTND;
ed_dbl(r, r);
} else {
/* use full extended coordinate doubling for last step */
ed_dbl(r, r);
}
} else {
ed_dbl(r, r);
if (n > 0) {
ed_add(r, r, t[n / 2]);
} else if (n < 0) {
ed_sub(r, r, t[-n / 2]);
}
}
}
/* Convert r to affine coordinates. */
ed_norm(r, r);
if (bn_sign(k) == RLC_NEG) {
ed_neg(r, r);
}
} | Base | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.