Example #1
0
int get_code(unsigned* pycbuf, struct code_obj* pobj, int cur, int size)
{
    int func_idx = 0;
    int op_arg = 0;
    int num_obj = 1;
    int dealt = 0;
    int len = length(pycbuf, cur-5);
    int end = cur + len;
    while (cur < end-1 && !(cur >= size)) {
        if(!(callable(cur, pycbuf))) {
            field_add(&(pobj->code), pycbuf[cur]);
            if (have_arg(pycbuf[cur])) {
                op_arg = get_op_arg(pycbuf, cur);
                field_add(&(pobj->code), op_arg);
                cur += 3;
            } else {
                cur += 1; 
            }
        } else {
            //printf("****:dealing function\n");
            dealt = find_next_callable(pycbuf, cur, num_obj);
            struct code_obj* pnew_obj = malloc(sizeof(*pnew_obj));
            func_idx = get_fields(pycbuf, pnew_obj, dealt, size); /* get fields of the entire code object */
            objects[func_idx]->val.pobj =  pnew_obj;
            objects[func_idx]->type =  TYPE_CODE;
            num_obj++;
            cur += 9; 
        }
    }
    field_add(&(pobj->code), pycbuf[cur]);
    return cur+1; 
}
Example #2
0
int get_consts(unsigned* pycbuf, struct code_obj* pobj, int cur, int size)
{
    int num_co = length(pycbuf, cur);
    int i = 0;
    cur += 5;
    while(i < num_co) {
        if (pycbuf[cur] == TYPE_INTEGER) { 
            field_add(&(pobj->consts), compute_const(pycbuf, cur));
            cur += 5;
        }
        else if (pycbuf[cur] == TYPE_NONE){
            field_add(&(pobj->consts), 0);
            cur += 1;
        } else if (pycbuf[cur] == TYPE_CODE) {
            field_add(&(pobj->consts), 0);
            cur = find_end_of_code(pycbuf, cur);
        }
        i++;
    }
    return cur; 
}
Example #3
0
  void DatabaseIO::create_group(EntityType type, const std::string & /*type_name*/,
                                const std::vector<std::string> &group_spec,
                                const SideSet * /*set_type*/)
  {
    // Not generalized yet... This only works for T == SideSet
    if (type != SIDESET) {
      return;
    }

    int64_t entity_count = 0;
    int64_t df_count     = 0;

    // Create the new set...
    auto new_set = new SideSet(this, group_spec[0]);

    get_region()->add(new_set);

    // Find the member SideSets...
    for (size_t i = 1; i < group_spec.size(); i++) {
      SideSet *set = get_region()->get_sideset(group_spec[i]);
      if (set != nullptr) {
        SideBlockContainer side_blocks = set->get_side_blocks();
        for (auto &sbold : side_blocks) {
          size_t side_count = sbold->get_property("entity_count").get_int();
          auto   sbnew      = new SideBlock(this, sbold->name(), sbold->topology()->name(),
                                     sbold->parent_element_topology()->name(), side_count);
          int64_t id = sbold->get_property("id").get_int();
          sbnew->property_add(Property("set_offset", entity_count));
          sbnew->property_add(Property("set_df_offset", df_count));
          sbnew->property_add(Property("id", id));

          new_set->add(sbnew);

          size_t old_df_count = sbold->get_property("distribution_factor_count").get_int();
          if (old_df_count > 0) {
            std::string storage = "Real[";
            storage += Utils::to_string(sbnew->topology()->number_nodes());
            storage += "]";
            sbnew->field_add(
                Field("distribution_factors", Field::REAL, storage, Field::MESH, side_count));
          }
          entity_count += side_count;
          df_count += old_df_count;
        }
      }
      else {
        IOSS_WARNING << "WARNING: While creating the grouped surface '" << group_spec[0]
                     << "', the surface '" << group_spec[i] << "' does not exist. "
                     << "This surface will skipped and not added to the group.\n\n";
      }
    }
  }
Example #4
0
// if you want a full multiplication, then make res.order = l.order + r.order
// but if you just care about a lower order, e.g. mul mod x^i, then you can select
//    fewer coefficients
void polynomial_mul(field_t field, polynomial_t l, polynomial_t r, polynomial_t res) {
    // perform an element-wise multiplication of two polynomials
    memset(res.coeff, 0, sizeof(field_element_t) * (res.order + 1));
    for (unsigned int i = 0; i <= l.order; i++) {
        if (i > res.order) {
            continue;
        }
        unsigned int j_limit = (r.order > res.order - i) ? res.order - i : r.order;
        for (unsigned int j = 0; j <= j_limit; j++) {
            // e.g. alpha^5*x * alpha^37*x^2 --> alpha^42*x^3
            res.coeff[i + j] = field_add(field, res.coeff[i + j], field_mul(field, l.coeff[i], r.coeff[j]));
        }
    }
}
int stmtsort_init(struct Stmt *sort)
{
	int		s		= 0;
	struct Field	*fld_in		= 0;
	struct Field	*fld_out	= 0;

	if (! sort->out) {
		sort->out = (struct StmtMeta *) calloc(1,
						sizeof(struct StmtMeta));
		if (! sort->out)
			return E_MEM;
	}

	if (sort->out->filename) {
		/* check if file output is exist */
		s = file_raw_is_exist(sort->out->filename);
		if (s) {
			str_raw_copy(sort->out->filename, &_vos.e_sparm0);
			return E_FILE_EXIST;
		}
	}

	if (! sort->out->alias) {
		s = str_raw_copy(sort->in->alias, &sort->out->alias);
		if (s)
			return s;
	}

	sort->out->flag = sort->in->flag;

	fld_in = sort->in->fields;
	while (fld_in) {
		fld_out = (struct Field *) calloc(1, sizeof(struct Field));
		if (! fld_out)
			return E_MEM;

		fld_out->idx		= fld_in->idx;
		fld_out->flag		= fld_in->flag;
		fld_out->type		= fld_in->type;
		if (fld_in->next)
			fld_out->sep	= '|';
		fld_out->name		= fld_in->name;
		fld_out->date_format	= fld_in->date_format;

		field_add(&sort->out->fields, fld_out);
		fld_in = fld_in->next;
	}

	return 0;
}
Example #6
0
field_element_t polynomial_eval_lut(field_t field, polynomial_t poly, const field_logarithm_t *val_exp) {
    // evaluate the polynomial poly at a particular element val
    // in this case, all of the logarithms of the successive powers of val have been precalculated
    // this removes the extra work we'd have to do to calculate val_exponentiated each time
    //   if this function is to be called on the same val multiple times
    if (val_exp[0] == 0) {
        return poly.coeff[0];
    }

    field_element_t res = 0;

    for (unsigned int i = 0; i <= poly.order; i++) {
        if (poly.coeff[i] != 0) {
            // multiply-accumulate by the next coeff times the next power of val
            res = field_add(field, res,
                    field_mul_log_element(field, field.log[poly.coeff[i]], val_exp[i]));
        }
    }
    return res;
}
Example #7
0
void polynomial_mod(field_t field, polynomial_t dividend, polynomial_t divisor, polynomial_t mod) {
    // find the polynomial remainder of dividend mod divisor
    // do long division and return just the remainder (written to mod)

    if (mod.order < dividend.order) {
        // mod.order must be >= dividend.order (scratch space needed)
        // this is an error -- catch it in debug?
        return;
    }
    // initialize remainder as dividend
    memcpy(mod.coeff, dividend.coeff, sizeof(field_element_t) * (dividend.order + 1));

    // XXX make sure divisor[divisor_order] is nonzero
    field_logarithm_t divisor_leading = field.log[divisor.coeff[divisor.order]];
    // long division steps along one order at a time, starting at the highest order
    for (unsigned int i = dividend.order; i > 0; i--) {
        // look at the leading coefficient of dividend and divisor
        // if leading coefficient of dividend / leading coefficient of divisor is q
        //   then the next row of subtraction will be q * divisor
        // if order of q < 0 then what we have is the remainder and we are done
        if (i < divisor.order) {
            break;
        }
        if (mod.coeff[i] == 0) {
            continue;
        }
        unsigned int q_order = i - divisor.order;
        field_logarithm_t q_coeff = field_div_log(field, field.log[mod.coeff[i]], divisor_leading);

        // now that we've chosen q, multiply the divisor by q and subtract from
        //   our remainder. subtracting in GF(2^8) is XOR, just like addition
        for (unsigned int j = 0; j <= divisor.order; j++) {
            if (divisor.coeff[j] == 0) {
                continue;
            }
            // all of the multiplication is shifted up by q_order places
            mod.coeff[j + q_order] = field_add(field, mod.coeff[j + q_order],
                        field_mul_log_element(field, field.log[divisor.coeff[j]], q_coeff));
        }
    }
}
Example #8
0
field_element_t polynomial_eval(field_t field, polynomial_t poly, field_element_t val) {
    // evaluate the polynomial poly at a particular element val
    if (val == 0) {
        return poly.coeff[0];
    }

    field_element_t res = 0;

    // we're going to start at 0th order and multiply by val each time
    field_logarithm_t val_exponentiated = field.log[1];
    field_logarithm_t val_log = field.log[val];

    for (unsigned int i = 0; i <= poly.order; i++) {
        if (poly.coeff[i] != 0) {
            // multiply-accumulate by the next coeff times the next power of val
            res = field_add(field, res,
                    field_mul_log_element(field, field.log[poly.coeff[i]], val_exponentiated));
        }
        // now advance to the next power
        val_exponentiated = field_mul_log(field, val_exponentiated, val_log);
    }
    return res;
}
Example #9
0
field_element_t polynomial_eval_log_lut(field_t field, polynomial_t poly_log, const field_logarithm_t *val_exp) {
    // evaluate the log_polynomial poly at a particular element val
    // like polynomial_eval_lut, the logarithms of the successive powers of val have been
    //   precomputed
    if (val_exp[0] == 0) {
        if (poly_log.coeff[0] == 0) {
            // special case for the non-existant log case
            return 0;
        }
        return field.exp[poly_log.coeff[0]];
    }

    field_element_t res = 0;

    for (unsigned int i = 0; i <= poly_log.order; i++) {
        // using 0 as a sentinel value in log -- log(0) is really -inf
        if (poly_log.coeff[i] != 0) {
            // multiply-accumulate by the next coeff times the next power of val
            res = field_add(field, res,
                    field_mul_log_element(field, poly_log.coeff[i], val_exp[i]));
        }
    }
    return res;
}
static int log_failure_mkfields(pool *p) {
  pr_table_t *fields;

  fields = pr_table_alloc(p, 0);
  if (pr_table_ctl(fields, PR_TABLE_CTL_SET_KEY_CMP,
      (void *) field_id_cmp) < 0) {
    int xerrno = errno;

    pr_log_pri(PR_LOG_INFO, "error setting key comparison callback for "
      "field ID/names: %s", strerror(errno));
    pr_table_free(fields);

    errno = xerrno;
    return -1;
  }

  if (pr_table_ctl(fields, PR_TABLE_CTL_SET_KEY_HASH,
      (void *) field_id_hash) < 0) {
    int xerrno = errno;

    pr_log_pri(PR_LOG_INFO, "error setting key hash callback for "
      "field ID/names: %s", strerror(errno));
    pr_table_free(fields);

    errno = xerrno;
    return -1;
  }

  /* Now populate the table with the ID/name values.  The key is the
   * LogFormat "meta" ID, and the value is the corresponding name string,
   * for use e.g. as JSON object member names.
   */

  field_add(p, fields, LOGFMT_META_BYTES_SENT, "bytes_sent",
    LOG_FAILURE_FIELD_TYPE_NUMBER);

  field_add(p, fields, LOGFMT_META_FILENAME, "file",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_ENV_VAR, "ENV:",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_REMOTE_HOST, "remote_dns",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_REMOTE_IP, "remote_ip",
    LOG_FAILURE_FIELD_TYPE_STRING);

#if defined(LOGFMT_META_REMOTE_PORT)
  field_add(p, fields, LOGFMT_META_REMOTE_PORT, "remote_port",
    LOG_FAILURE_FIELD_TYPE_NUMBER);
#endif /* LOGFMT_META_REMOTE_PORT */

  field_add(p, fields, LOGFMT_META_IDENT_USER, "identd_user",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_PID, "pid",
    LOG_FAILURE_FIELD_TYPE_NUMBER);

  field_add(p, fields, LOGFMT_META_TIME, "local_time",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_SECONDS, "transfer_secs",
    LOG_FAILURE_FIELD_TYPE_NUMBER);

  field_add(p, fields, LOGFMT_META_COMMAND, "raw_command",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_LOCAL_NAME, "server_name",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_LOCAL_PORT, "local_port",
    LOG_FAILURE_FIELD_TYPE_NUMBER);

  field_add(p, fields, LOGFMT_META_LOCAL_IP, "local_ip",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_LOCAL_FQDN, "server_dns",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_USER, "user",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_ORIGINAL_USER, "original_user",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_RESPONSE_CODE, "response_code",
    LOG_FAILURE_FIELD_TYPE_NUMBER);

#if defined(LOGFMT_META_RESPONSE_MS)
  field_add(p, fields, LOGFMT_META_RESPONSE_MS, "response_ms",
    LOG_FAILURE_FIELD_TYPE_NUMBER);
#endif /* LOGFMT_META_RESPONSE_MS */

  field_add(p, fields, LOGFMT_META_CLASS, "connection_class",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_ANON_PASS, "anon_password",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_METHOD, "command",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_XFER_PATH, "transfer_path",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_DIR_NAME, "dir_name",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_DIR_PATH, "dir_path",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_CMD_PARAMS, "command_params",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_RESPONSE_STR, "response_msg",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_PROTOCOL, "protocol",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_VERSION, "server_version",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_RENAME_FROM, "rename_from",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_FILE_MODIFIED, "file_modified",
    LOG_FAILURE_FIELD_TYPE_BOOLEAN);

  field_add(p, fields, LOGFMT_META_UID, "uid",
    LOG_FAILURE_FIELD_TYPE_NUMBER);

  field_add(p, fields, LOGFMT_META_GID, "gid",
    LOG_FAILURE_FIELD_TYPE_NUMBER);

  field_add(p, fields, LOGFMT_META_RAW_BYTES_IN, "session_bytes_rcvd",
    LOG_FAILURE_FIELD_TYPE_NUMBER);

  field_add(p, fields, LOGFMT_META_RAW_BYTES_OUT, "session_bytes_sent",
    LOG_FAILURE_FIELD_TYPE_NUMBER);

  field_add(p, fields, LOGFMT_META_EOS_REASON, "session_end_reason",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_VHOST_IP, "server_ip",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_NOTE_VAR, "NOTE:",
    LOG_FAILURE_FIELD_TYPE_STRING);

#if defined(LOGFMT_META_XFER_MS)
  field_add(p, fields, LOGFMT_META_XFER_MS, "transfer_ms",
    LOG_FAILURE_FIELD_TYPE_NUMBER);
#endif /* LOGFMT_META_XFER_MS */

  field_add(p, fields, LOGFMT_META_XFER_STATUS, "transfer_status",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_XFER_FAILURE, "transfer_failure",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_MICROSECS, "microsecs",
    LOG_FAILURE_FIELD_TYPE_NUMBER);

  field_add(p, fields, LOGFMT_META_MILLISECS, "millisecs",
    LOG_FAILURE_FIELD_TYPE_NUMBER);

  field_add(p, fields, LOGFMT_META_ISO8601, "timestamp",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOGFMT_META_GROUP, "group",
    LOG_FAILURE_FIELD_TYPE_STRING);

  field_add(p, fields, LOG_FAILURE_META_CONNECT, "connecting",
    LOG_FAILURE_FIELD_TYPE_BOOLEAN);

  field_add(p, fields, LOG_FAILURE_META_DISCONNECT, "disconnecting",
    LOG_FAILURE_FIELD_TYPE_BOOLEAN);

  log_failure_fields = fields;
  return 0;
}
Example #11
0
static int
goldilocks_shared_secret_core (
    uint8_t shared[GOLDI_SHARED_SECRET_BYTES],
    const struct goldilocks_private_key_t *my_privkey,
    const struct goldilocks_public_key_t *your_pubkey,
    const struct goldilocks_precomputed_public_key_t *pre
) {
    /* This function doesn't actually need anything in goldilocks_global,
     * so it doesn't check init.
     */

    assert(GOLDI_SHARED_SECRET_BYTES == SHA512_OUTPUT_BYTES);

    word_t sk[GOLDI_FIELD_WORDS];
    struct field_t pk;

    mask_t succ = field_deserialize(&pk,your_pubkey->opaque), msucc = -1;

#ifdef EXPERIMENT_ECDH_STIR_IN_PUBKEYS
    struct field_t sum, prod;
    msucc &= field_deserialize(&sum,&my_privkey->opaque[GOLDI_FIELD_BYTES]);
    field_mul(&prod,&pk,&sum);
    field_add(&sum,&pk,&sum);
#endif

    msucc &= barrett_deserialize(sk,my_privkey->opaque,&curve_prime_order);

#if GOLDI_IMPLEMENT_PRECOMPUTED_KEYS
    if (pre) {
        struct tw_extensible_t tw;
        succ &= scalarmul_fixed_base(&tw, sk, GOLDI_SCALAR_BITS, &pre->table);
        untwist_and_double_and_serialize(&pk, &tw);
    } else {
        succ &= montgomery_ladder(&pk,&pk,sk,GOLDI_SCALAR_BITS,1);
    }
#else
    (void)pre;
    succ &= montgomery_ladder(&pk,&pk,sk,GOLDI_SCALAR_BITS,1);
#endif


    field_serialize(shared,&pk);

    /* obliterate records of our failure by adjusting with obliteration key */
    struct sha512_ctx_t ctx;
    sha512_init(&ctx);

#ifdef EXPERIMENT_ECDH_OBLITERATE_CT
    uint8_t oblit[GOLDI_DIVERSIFY_BYTES + GOLDI_SYMKEY_BYTES];
    unsigned i;
    for (i=0; i<GOLDI_DIVERSIFY_BYTES; i++) {
        oblit[i] = "noshared"[i] & ~(succ&msucc);
    }
    for (i=0; i<GOLDI_SYMKEY_BYTES; i++) {
        oblit[GOLDI_DIVERSIFY_BYTES+i] = my_privkey->opaque[2*GOLDI_FIELD_BYTES+i] & ~(succ&msucc);
    }
    sha512_update(&ctx, oblit, sizeof(oblit));
#endif

#ifdef EXPERIMENT_ECDH_STIR_IN_PUBKEYS
    /* stir in the sum and product of the pubkeys. */
    uint8_t a_pk[GOLDI_FIELD_BYTES];
    field_serialize(a_pk, &sum);
    sha512_update(&ctx, a_pk, GOLDI_FIELD_BYTES);
    field_serialize(a_pk, &prod);
    sha512_update(&ctx, a_pk, GOLDI_FIELD_BYTES);
#endif

    /* stir in the shared key and finish */
    sha512_update(&ctx, shared, GOLDI_FIELD_BYTES);
    sha512_final(&ctx, shared);

    return (GOLDI_ECORRUPT & ~msucc)
           | (GOLDI_EINVAL & msucc &~ succ)
           | (GOLDI_EOK & msucc & succ);
}