Exemple #1
0
shkey_t *shecdsa_key_pub(shkey_t *priv_key)
{
#ifdef HAVE_LIBGMP
  ecdsa_parameters curve;
  mpz_t temp;
  mpz_t key;
  char pub_key[256];
  char *comp_hex;

  /* setup parameters */
  curve = ecdsa_parameters_init();
  ecdsa_parameters_load_curve(curve, secp160r1);

  /* initialize public key */
  ecdsa_point Q = ecdsa_point_init();
  mpz_init(key);
#if 0
  priv_key_hex = shkey_hex(priv_key);
  str_hash = shsha1_hash(priv_key_hex, strlen(priv_key_hex));
  mpz_set_str(key, str_hash, 16);
#endif
  mpz_set_str(key, shkey_hex(priv_key), 16);

#if 0
  /* key modulo n */
  mpz_init(temp);
  mpz_mod(temp, key, curve->n);
  mpz_set(key, temp);
  mpz_clear(temp);
#endif
 
  /* generate public key */
  memset(pub_key, 0, sizeof(pub_key));
  ecdsa_signature_generate_key(Q, key, curve);


  comp_hex = ecdsa_point_compress(Q, 21); 
  if (!comp_hex) return (NULL);
  strncpy(pub_key, comp_hex, sizeof(pub_key)-1);
  free(comp_hex);

  ecdsa_parameters_clear(curve);
  ecdsa_point_clear(Q);
  mpz_clear(key);

  return (shecdsa_key(pub_key));
#else
  return (NULL);
#endif
}
Exemple #2
0
int sexe_event_remove(lua_State *L, int e_type, char *e_name)
{
  sexe_event_t t_event;
  sexe_event_t *e;
  shkey_t *key;
  int err;

  memset(&t_event, 0, sizeof(t_event));
  t_event.event_type = e_type;
  strncpy(t_event.mod_name, e_name, sizeof(t_event.mod_name) - 1);
  key = shkey_bin(&t_event, sizeof(sexe_event_t));

  /* remove event's global callback */
  lua_pushnil(L); 
  lua_setglobal(L, shkey_hex(key));

  e = (sexe_event_t *)shmap_get_ptr(event_map, key);
  if (e) {
    shmap_unset(event_map, key);
    free(e);
  }
  shkey_free(&key);

  return (0);
}
Exemple #3
0
int install_sexe_userdata(sexe_t *S, char *tag)
{
  SHFL *fl;
  shjson_t *udata;
  shfs_t *fs;
  shbuf_t *buff;
  shkey_t *k;
  char path[PATH_MAX+1];
  int is_new;

  k = shkey_str(tag);
  sprintf(path, "/sys/data/sexe/%s", shkey_hex(k)); 
  memcpy(&S->pname, k, sizeof(S->pname));
  shkey_free(&k);

  buff = shbuf_init();
  fs = shfs_init(NULL);
  fl = shfs_file_find(fs, path);
  is_new = shfs_read(fl, buff);

  udata = shjson_init(shbuf_size(buff) ? (char *)shbuf_data(buff) : NULL);
  shbuf_free(&buff);

  if (is_new)
    shjson_num_add(udata, "birth", shtimef(shtime()));

  sexe_table_set(S, udata);
  lua_setglobal(S, "userdata");
  shjson_free(&udata);

  shfs_free(&fs);

  return (0);
}
Exemple #4
0
/**
 * Store supplementary credential data in a file.
 */
int shfs_cred_store(shfs_ino_t *file, shkey_t *key, unsigned char *data, size_t data_len)
{
  shfs_ino_t *cred;
  shbuf_t *buff;
  char key_buf[MAX_SHARE_HASH_LENGTH];
  int err;

  memset(key_buf, 0, sizeof(key_buf));
  sprintf(key_buf, "%s", shkey_hex(key));
  cred = shfs_inode(file, key_buf, SHINODE_ACCESS);
  if (!cred)
    return (SHERR_IO);

  cred->blk.hdr.format = SHINODE_ACCESS;
  buff = shbuf_map(data, data_len);
  err = shfs_aux_write(cred, buff);
  free(buff);
  if (err)
    return (err);

  file->blk.hdr.attr |= SHATTR_CRED;
  file->blk.hdr.crc = shcrc(data, data_len);
  file->blk.hdr.size = data_len;
  err = shfs_inode_write_entity(file);
  if (err)
    return (err);

  return (0);
}
Exemple #5
0
int txop_ward_confirm(shpeer_t *peer, tx_ward_t *ward)
{
  tx_context_t *ctx;
  tx_t *tx;
  int err;

#if 0
  /* verify identity exists */
  ctx = (tx_context_t *)tx_load(TX_CONTEXT, &ward->ward_ctx);
  if (!ctx)
    return (SHERR_NOKEY);
/* .. */
  pstore_free(ctx);

  err = confirm_signature(&ward->ward_sig, 
      shpeer_kpriv(&ward->ward_peer), shkey_hex(&ward->ward_key));
  pstore_free(tx);
  if (err)
    return (err);

  err = inittx_context(ctx, get_tx_key(ward), ashkey_uniq());
  if (err)
    return (err);
#endif

  return (0);
}
Exemple #6
0
static int _shcert_sign_verify_ecdsa(shcert_t *cert, shcert_t *parent)
{
  shkey_t *pub_key;
  char *hex_data;
  unsigned char data[256];
  int data_len;
  int err;

  if (parent) {
    if (!shkey_cmp(shcert_sub_sig(parent), shcert_iss_sig(cert))) {
      return (SHERR_INVAL);
    }
  }

  hex_data = shkey_hex(&cert->cert_iss.ent_sig.sig_key);
  data_len = strlen(hex_data) / 2;
  if (!data_len) {
    return (SHERR_INVAL);
  }

  memset(data, 0, sizeof(data));
  hex2bin(data, hex_data, data_len);

  pub_key = &cert->cert_sub.ent_sig.sig_key;
  err = shecdsa_verify(pub_key, 
    cert->cert_sub.ent_sig.key.ecdsa.sig_r,
    cert->cert_sub.ent_sig.key.ecdsa.sig_s,
    data, data_len);
  if (err)
    return (err);

  return (0);
}
Exemple #7
0
void *tx_load(int tx_op, shkey_t *tx_key)
{

  if (!is_tx_stored(tx_op))
    return (NULL);

  return (pstore_load(tx_op, shkey_hex(tx_key)));
}
Exemple #8
0
/**
 * @returns An allocated parent transaction or NULL.
 */
tx_t *get_tx_parent(tx_t *tx)
{
  tx_t *p_tx;

  if (0 == shkey_cmp(&tx->tx_pkey, ashkey_blank()))
    return (NULL);

  return ((tx_t *)pstore_load(tx->tx_ptype, shkey_hex(&tx->tx_pkey)));
}
Exemple #9
0
/**
 * @note does not return allocated memory 
 */
shpeer_t *load_asset_peer(shkey_t *id_key)
{
  static shpeer_t ret_peer;
  tx_id_t *id;

  id = (tx_id_t *)pstore_load(TX_IDENT, (char *)shkey_hex(id_key));
  if (!id)
    return (NULL);

  memcpy(&ret_peer, &id->id_peer, sizeof(shpeer_t));
  return (&ret_peer);
}
Exemple #10
0
int shecdsa_verify(shkey_t *pub_key, char *str_r, char *str_s, unsigned char *data, size_t data_len)
{
#ifdef HAVE_LIBGMP
  ecdsa_parameters curve;
  ecdsa_signature sig;
  ecdsa_point Q;
  mpz_t temp;
  mpz_t m;
  uint8_t *hash;
  int ok;


  /* setup parameters */
  curve = ecdsa_parameters_init();
  ecdsa_parameters_load_curve(curve, secp160r1);

  /* decompress public key */
  Q = ecdsa_point_init();
  ecdsa_point_decompress(Q, (char *)shkey_hex(pub_key), curve);

  /* process message into sha1 hash */
  mpz_init(m);
  hash = shsha1_hash(data, data_len);
  mpz_set_str(m, hash, 16);

  /* msg modulo n - note standard is bit-length not mod */
  mpz_init(temp);
  mpz_mod(temp, m, curve->n);
  mpz_set(m, temp);
  mpz_clear(temp);

  sig = ecdsa_signature_init();
  ecdsa_signature_set_str(sig, str_r, str_s, 16);

  /* verify signature */
  ok = ecdsa_signature_verify(m, sig, Q, curve);

  ecdsa_parameters_clear(curve);
  ecdsa_signature_clear(sig);
  ecdsa_point_clear(Q);
  mpz_clear(m);

  if (!ok)
    return (SHERR_ACCESS);


  return (0);
#else
  return (SHERR_OPNOTSUPP);
#endif
}
Exemple #11
0
shfs_ino_t *shfs_rev_get(shfs_ino_t *repo, shkey_t *rev_key)
{
  shfs_ino_t *rev;

  if (shfs_type(repo) == SHINODE_FILE)
    repo = shfs_inode(repo, NULL, SHINODE_REPOSITORY);
  if (shfs_type(repo) != SHINODE_REPOSITORY)
    return (NULL);

  if (shkey_cmp(rev_key, ashkey_blank()))
    return (NULL);

  return (shfs_inode(repo, (char *)shkey_hex(rev_key), SHINODE_REVISION));
}
Exemple #12
0
int pstore_save(void *data, size_t data_len)
{
    tx_t *tx;
    shkey_t *s_key;

    tx = (tx_t *)data;

    s_key = get_tx_key(tx);
    if (!s_key)
        return (SHERR_INVAL);

    pstore_write(tx->tx_op, (char *)shkey_hex(s_key),
                 (unsigned char *)data, data_len);

    return (0);
}
Exemple #13
0
int update_sexe_userdata(sexe_t *S)
{
  SHFL *fl;
  shjson_t *udata;
  shfs_t *fs;
  shbuf_t *buff;
  shkey_t *k;
  char path[PATH_MAX+1];
  char *str;
  int err;

  k = &S->pname;
  if (shkey_cmp(k, ashkey_blank())) {
fprintf(stderr, "DEBUG: update_sexe_userdata: no app key\n");
    return (0); /* blank */
  }
  sprintf(path, "/sys/data/sexe/%s", shkey_hex(k)); 

  lua_getglobal(S, "userdata");
  udata = sexe_table_get(S);
  if (!udata) {
fprintf(stderr, "DEBUG: update_sexe_userdata: no global 'userdata' variable.\n");
    return (SHERR_INVAL);
  }

  str = shjson_print(udata);
  if (!str) {
fprintf(stderr, "DEBUG: update_sexe_userdata: error encoding JSON.\n");
    return (SHERR_INVAL);
}
  shjson_free(&udata);

  buff = shbuf_init();
  shbuf_catstr(buff, str);
  free(str);


  fs = shfs_init(NULL);
  fl = shfs_file_find(fs, path);
  err = shfs_write(fl, buff);
  shbuf_free(&buff);
  shfs_free(&fs);

  return (err);
}
Exemple #14
0
int pstore_delete_tx(tx_t *tx)
{
    shkey_t *s_key;
    int err;

    if (!tx)
        return (SHERR_INVAL);

    s_key = get_tx_key(tx);
    if (!s_key)
        return (SHERR_INVAL);

    err = pstore_delete(tx->tx_op, (char *)shkey_hex(s_key));
    if (err)
        return (err);

    return (0);
}
Exemple #15
0
shkey_t *shfs_index_key(shfs_idx_t *idx, uint64_t crc, shfs_dirent_t *ent_p)
{
  shkey_t *key;
  int h_num = (crc % 256);
  
  if (!idx->hash[h_num]) {
    key = shkey_bin(&crc, sizeof(uint64_t));
    idx->hash_ino[h_num] = shfs_inode(idx->file, shkey_hex(key), SHINODE_INDEX);
    shkey_free(&key);
    return (NULL);
  }
  for (i = 0; i < idx->hash_max[h_num]; i++) {
    if ((idx->key[h_num] + i) == crc) {
      return (idx->hash[h_num] + i); 
    }
  }

  return (NULL);
}
Exemple #16
0
/**
 * Generate a public key.
 */
shkey_t *shecdsa_key_priv(char *hex_seed)
{
#ifdef HAVE_LIBGMP
  ecdsa_parameters curve;
  mpz_t d;
  shkey_t *ret_key;
  shkey_t *ukey;

#if 0
  /* setup parameters */
  curve = ecdsa_parameters_init();
  ecdsa_parameters_load_curve(curve, secp160r1);

  /* public key */
  ecdsa_point Q = ecdsa_point_init();
  ecdsa_point Q_check = ecdsa_point_init();
#endif

  if (hex_seed) {
    ukey = shkey_hexgen(hex_seed);
  } else {
    ukey = shkey_uniq(); /* generate random */
  }
  if (!ukey) {
fprintf(stderr, "DEBUG: shecdsa_key_priv: !ukey\n"); 
    return (NULL);
  }
  /* truncate to "21 bytes" */
  ukey->code[5] = (ukey->code[5] & 0xff);
  ukey->code[6] = 0;
  ukey->code[7] = 0;
  ukey->alg = SHKEY_ALG_ECDSA;

  ret_key = shecdsa_key((char *)shkey_hex(ukey));

  shkey_free(&ukey);

  return (ret_key);
#else
  return (NULL);
#endif
}
Exemple #17
0
int shfs_cred_remove(shfs_ino_t *file, shkey_t *key)
{
  shfs_ino_t *cred;
  char key_buf[MAX_SHARE_HASH_LENGTH];
  int err;

  memset(key_buf, 0, sizeof(key_buf));
  sprintf(key_buf, "%s", shkey_hex(key));
  cred = shfs_inode(file, key_buf, SHINODE_ACCESS);
  if (!cred)
    return (SHERR_IO);

  if (shfs_format(cred) != SHINODE_ACCESS)
    return (0); /* done */

  err = shfs_inode_clear(cred);
  if (err)
    return (err);

  return (0);
}
Exemple #18
0
int sexe_event_handle(lua_State *L, int e_type, shjson_t *json)
{
  const shmap_t *h = event_map;
  shmap_index_t *hi;
  sexe_event_t *event;
  char *key;
  char *val;
  size_t len;
  int flag;

  for (hi = shmap_first(h); hi; hi = shmap_next(hi)) {
    shmap_self(hi,(void*) &key, (void*) &val, &len, &flag);
    if (!(flag & SHMAP_BINARY))
      continue;

    event = (sexe_event_t *)val;
    if (event->event_type != e_type)
      continue; /* wrong event type */

    sexe_event_call(L, shkey_hex(&event->reg_key), e_type, json);
  }

}
Exemple #19
0
/**
 * Load supplementary credential data from a file.
 */
int shfs_cred_load(shfs_ino_t *file, shkey_t *key, unsigned char *data, size_t max_len)
{
  shfs_ino_t *cred;
  shbuf_t *buff;
  char key_buf[MAX_SHARE_HASH_LENGTH];
  int err;

  if (!(file->blk.hdr.attr & SHATTR_CRED))
    return (SHERR_NOENT);

  memset(key_buf, 0, sizeof(key_buf));
  sprintf(key_buf, "%s", shkey_hex(key));
  cred = shfs_inode(file, key_buf, SHINODE_ACCESS);
  if (!cred)
    return (SHERR_IO);

  if (cred->blk.hdr.format != SHINODE_ACCESS)
    return (SHERR_NOENT);

  buff = shbuf_init();
  err = shfs_aux_read(cred, buff);
  if (err) {
    shbuf_free(&buff);
    return (err);
  }
  if (shbuf_size(buff) == 0) {
    shbuf_free(&buff);
    return (SHERR_IO);
  }

  /* copy buffer */
  memcpy(data, shbuf_data(buff), MIN(shbuf_size(buff), max_len));
  shbuf_free(&buff);

  return (0);
}
Exemple #20
0
/**
 * The "os.register(<string>,<function>)" function will register a callback function for the event name specified.
 */
int _lfunc_register_event(sexe_t *L)
{
	int ef_nr = sexe_event_next_id();
  const char *e_name = (int)luaL_checkstring(L, 1);
	shkey_t *key = sexe_event_key(e_name);
	char *ptr = shkey_hex(key);

	/* _EVENT table */
	lua_getglobal(L, EVENT_ENV);  
	if (lua_isnil(L, -1)) {
		lua_pop(L, 1);
		/* _EVENT */
		lua_createtable(L, 0, 1);
	}

	/* _EVENT[<id>] */
	lua_pushstring(L, ptr);
	lua_getfield(L, -2, ptr);
	if (lua_isnil(L, -1)) {
		lua_pop(L, 1);
		lua_newtable(L);
	}

	/* event callback function */
	lua_pushnumber(L, ef_nr);
	lua_pushvalue(L, 2);
	lua_settable(L, -3);

	/* set _ENV['_EVENT'][<id>] */
	lua_settable(L, -3);

	/* set _ENV['_EVENT'] */
	lua_setglobal(L, EVENT_ENV);

  return (0);
}
Exemple #21
0
char *sexe_event_init(int e_type, const char *e_name)
{
  static char key_str[256];
  sexe_event_t *e;
  shkey_t *key;

  if (!event_map) {
    event_map = shmap_init();
  }

  e = (sexe_event_t *)calloc(1, sizeof(sexe_event_t));
  if (!e)
    return (SHERR_NOMEM);

  e->event_type = e_type;
  strncpy(e->mod_name, e_name, sizeof(e->mod_name) - 1);
  key = shkey_bin(e, sizeof(sexe_event_t));
  memcpy(&e->reg_key, key, sizeof(shkey_t));
  shmap_set_ptr(event_map, key, e);
  strncpy(key_str, shkey_hex(key), sizeof(key_str) - 1);
  shkey_free(&key);

  return (key_str);
}
Exemple #22
0
tx_bond_t *load_bond(shkey_t *bond_key)
{
  return ((tx_bond_t *)pstore_load(TX_FILE, shkey_hex(bond_key)));
}
Exemple #23
0
int shecdsa_sign(shkey_t *priv_key, char *sig_r, char *sig_s, unsigned char *data, size_t data_len)
{
#ifdef HAVE_LIBGMP
  ecdsa_parameters curve;
  ecdsa_signature sig;
  uint8_t *hash;
  mpz_t temp;
  mpz_t key;
  mpz_t m;

  /* setup parameters */
  curve = ecdsa_parameters_init();
  ecdsa_parameters_load_curve(curve, secp160r1);

  /* generate private key from user-context */
  mpz_init(key);
#if 0
  priv_key_hex = shkey_hex(priv_key);
  hash = shsha1_hash(priv_key_hex, strlen(priv_key_hex));
  mpz_set_str(key, hash, 16);
#endif
  mpz_set_str(key, shkey_hex(priv_key), 16);

#if 0
  /* key modulo n */
  mpz_init(temp);
  mpz_mod(temp, key, curve->n);
  mpz_set(key, temp);
#endif

  /* process message into sha1 hash */
  mpz_init(m);
  hash = shsha1_hash(data, data_len);
  mpz_set_str(m, hash, 16);

  /* msg modulo n */
  mpz_init(temp);
  mpz_mod(temp, m, curve->n);
  mpz_set(m, temp);
  mpz_clear(temp);

  /* generate signature */
  sig = ecdsa_signature_init();
  ecdsa_signature_sign(sig, m, key, curve);

#if 0
  {
    FILE *out = stdout;
    fprintf(out, "Signature:\n\tR:");
    mpz_out_str(out, 16, sig->r);
    fprintf(out, "\n\tS:");
    mpz_out_str(out, 16, sig->s);
    fprintf(out, "\n");
  }
#endif

  memset(sig_r, 0, sizeof(sig_r));
  strcpy(sig_r, mpz_get_str(NULL, 16, sig->r));

  memset(sig_s, 0, sizeof(sig_s));
  strcpy(sig_s, mpz_get_str(NULL, 16, sig->s));

  ecdsa_parameters_clear(curve);
  ecdsa_signature_clear(sig);
  mpz_clear(key);
  mpz_clear(m);

  return (0);
#else
  return (SHERR_OPNOTSUPP);
#endif
}
Exemple #24
0
void shcert_print(shcert_t *cert, shbuf_t *pr_buff)
{
  char tbuf1[256];
  char tbuf2[256];
  char buf[4096];

  if (!cert || !pr_buff)
    return;

  shbuf_catstr(pr_buff, "Certificate:\n");
  shbuf_catstr(pr_buff, "  Data:\n");

  sprintf(buf, "    Version: %d\n", cert->cert_ver);
  shbuf_catstr(pr_buff, buf);

  shbuf_catstr(pr_buff, "    Serial Number: ");
  shcert_hex_print(pr_buff, shcert_sub_ser(cert), sizeof(shcert_sub_ser(cert)), "");

  sprintf(buf, "  Signature Algorithm: %s\n", 
      shsig_alg_str(shcert_iss_alg(cert) | shcert_sub_alg(cert)));
  shbuf_catstr(pr_buff, buf);

  sprintf(buf, "    Issuer: %s\n", cert->cert_iss.ent_name);
  shbuf_catstr(pr_buff, buf);

  strcpy(tbuf1, shctime(shcert_sub_stamp(cert))+4);
  strcpy(tbuf2, shctime(shcert_sub_expire(cert))+4);
  sprintf(buf, "    Validity: %-20.20s - %-20.20s\n", tbuf1, tbuf2); 
  shbuf_catstr(pr_buff, buf);

  sprintf(buf, "    Subject: %s\n", cert->cert_sub.ent_name);
  shbuf_catstr(pr_buff, buf);

  sprintf(buf, "    Public Key Algorithm: (%d bit) %s\n",
      shcert_sub_len(cert) * 8, shsig_alg_str(shcert_sub_alg(cert)));
  shbuf_catstr(pr_buff, buf);

  sprintf(buf, "      Checksum: %llu\n", shkey_crc(shcert_sub_sig(cert)));
  sprintf(buf, "      192-Bit: %s\n", shkey_hex(shcert_sub_sig(cert)));
  shbuf_catstr(pr_buff, buf);

  if (shcert_sub_alg(cert) & SHKEY_ALG_RSA) {
    shbuf_catstr(pr_buff, "      Modulus:\n");
    shcert_hex_print_reverse(pr_buff, cert->cert_sub.ent_sig.key.rsa.mod, 
        cert->cert_sub.ent_sig.key.rsa.mod_len, "        ");
  }

  shbuf_catstr(pr_buff, "    X509v3 extensions:\n");
  sprintf(buf, "      Basic Constraints: CA=%s\n", 
      (cert->cert_flag & SHCERT_CERT_CHAIN) ? "false" : "true");
  shbuf_catstr(pr_buff, buf);

  if (!shpeer_localhost(&cert->cert_sub.ent_peer)) {
    sprintf(buf, "      Alternate Subject: %s\n", 
        shpeer_print(&cert->cert_sub.ent_peer));
    shbuf_catstr(pr_buff, buf);
  }

  sprintf(buf, "      Extended Usage: %s\n", shcert_flag_str(cert->cert_flag));
  shbuf_catstr(pr_buff, buf);

  sprintf(buf, "  Private Signature: %s (%d bytes)\n",
      shsig_alg_str(shcert_iss_alg(cert)), shcert_iss_len(cert));
  shbuf_catstr(pr_buff, buf);

  if (shcert_iss_alg(cert) & SHKEY_ALG_MD5) {
    shcert_hex_print(pr_buff, cert->cert_iss.ent_sig.key.md.md, 
        cert->cert_iss.ent_sig.key.md.md_len, "    ");
  } else if (shcert_iss_alg(cert) & SHKEY_ALG_SHA1) {
    shcert_hex_print(pr_buff, cert->cert_iss.ent_sig.key.sha.sha, 
        cert->cert_iss.ent_sig.key.sha.sha_len, "    ");
  } else if (shcert_iss_alg(cert) & SHKEY_ALG_SHA256) {
    shcert_hex_print(pr_buff, cert->cert_iss.ent_sig.key.sha.sha, 
        cert->cert_iss.ent_sig.key.sha.sha_len, "    ");
  } else {
    sprintf(buf, "    Checksum: %llu\n", shkey_crc(shcert_iss_sig(cert)));
    shbuf_catstr(pr_buff, buf);
    sprintf(buf, "    192-Bit: %s\n", shkey_hex(shcert_iss_sig(cert)));
    shbuf_catstr(pr_buff, buf);
  }


}
Exemple #25
0
/**
 * @see shsig_shr_sign()
 */
int shcert_sign(shcert_t *cert, shcert_t *parent)
{
  shkey_t *key;
  unsigned char *enc_data;
  size_t enc_len;
  int err;

  if (!parent)
    return (SHERR_INVAL);

  if (!(parent->cert_flag & SHCERT_CERT_SIGN)) {
    /* parent certificate lacks ability to sign. */
    return (SHERR_INVAL);
  }

  /* assign issuer's 128-bit serial number (regardless of algorythm)  */
  memcpy(cert->cert_iss.ent_ser, parent->cert_sub.ent_ser, 16);

  if (cert->cert_sub.ent_sig.sig_key.alg == SHKEY_ALG_ECDSA) {
    shkey_t *pub_key = &cert->cert_sub.ent_sig.sig_key;
    shkey_t *priv_key;
    shkey_t *seed_key;
    shpeer_t *peer;
    char sig_r[256];
    char sig_s[256];
    char *hex_data;
    unsigned char data[256];
    int data_len;


    /* fill in parent signature */
    memcpy(&cert->cert_iss.ent_sig, &parent->cert_sub.ent_sig, sizeof(shsig_t));

    peer = shpeer_init(NULL, NULL);
    seed_key = shpeer_kpriv(peer);
    priv_key = shecdsa_key_priv(shkey_hex(seed_key));
    shpeer_free(&peer);

    pub_key = shecdsa_key_pub(priv_key);
    memcpy(&cert->cert_sub.ent_sig.sig_key, pub_key, sizeof(shkey_t));

    if ((parent->cert_flag & SHCERT_CERT_NONREPUDIATION)) {
      /* must be derived from owner to preserve authenticy. */
      if (!shkey_cmp(&cert->cert_sub.ent_sig.sig_key, 
            &cert->cert_iss.ent_sig.sig_key)) {
        return (SHERR_ACCESS);
      }
    }

    hex_data = shkey_hex(&cert->cert_iss.ent_sig.sig_key);
    data_len = strlen(hex_data) / 2;
    memset(data, 0, sizeof(data));
    hex2bin(data, hex_data, data_len);

    shecdsa_sign(priv_key, sig_r, sig_s, data, data_len);
    strcpy(cert->cert_sub.ent_sig.key.ecdsa.sig_r, sig_r);
    strcpy(cert->cert_sub.ent_sig.key.ecdsa.sig_s, sig_s);
    cert->cert_sub.ent_len = data_len;

    shkey_free(&pub_key);
    shkey_free(&priv_key);
  } else {
    err = shencode((char *)&parent->cert_sub.ent_sig.sig_key, sizeof(shkey_t),
      &enc_data, &enc_len, &parent->cert_iss.ent_sig.sig_key);
    if (err)
      return (err);

    key = shkey_bin(enc_data, enc_len);
    free(enc_data);
    memcpy(&cert->cert_sub.ent_sig.sig_key, key, sizeof(shkey_t));
    cert->cert_sub.ent_len = enc_len;
    shkey_free(&key);
  }

  cert->cert_flag |= SHCERT_CERT_CHAIN;
  cert->cert_flag |= parent->cert_flag; /* inherit parent's attributes */
  cert->cert_sub.ent_sig.sig_key.alg = parent->cert_sub.ent_sig.sig_key.alg;

  strcpy(cert->cert_iss.ent_name, parent->cert_sub.ent_name); 
  cert->cert_iss.ent_sig.sig_stamp = parent->cert_sub.ent_sig.sig_stamp;
  cert->cert_iss.ent_sig.sig_expire = parent->cert_sub.ent_sig.sig_expire;
  cert->cert_iss.ent_len = parent->cert_sub.ent_len;


  return (0);
}
Exemple #26
0
/**
 * The "os.trigger(<string>[,<table>])" function will trigger all callbacks for the specifid event name to be called with an optional object argument.
 */
int lfunc_trigger_event(sexe_t *L)
{
  const char *e_name;
  shjson_t *json;
  int t_reg = 0;
	int ret_bool;
	int err;

	/* first argument: event name */
	e_name = (int)luaL_checkstring(L, 1);

  /* second optional arg; table of data. */
  json = NULL;
  if (lua_istable(L, 2)) {
    lua_pushvalue(L, 2);
    json = sexe_table_get(L);
  }

	ret_bool = 1; 
	err = sexe_event_handle(L, e_name, json);
	if (err)
		ret_bool = 0;

#if 0

	/* iterate through registered functions for event */
	{
	  shkey_t *key = sexe_event_key(e_name);
		char *e_hex = shkey_hex(key);
		lua_getglobal(L, EVENT_ENV);
		if (lua_isnil(L, -1)) {
			return (0); /* error */
		}
		lua_getfield(L, -1, e_hex);
		if (lua_isnil(L, -1)) {
			return (0); /* error */
		}

		lua_pushnil(L);
		while (lua_next(L, -2)) {
			int t = lua_type(L, -1);
			if (t == LUA_TFUNCTION) {
				/* copy function call onto stack  lua_pushvalue(L, 1); */
				/* 1. user args */
				if (json)
					sexe_table_set(L, json);
				else
					lua_pushnil(L);
				/* 2. event name */
				lua_pushstring(L, e_name);
				/* exec */
				lua_pcall(L, 2, 0, 0); 
			} else {
				lua_pop(L, 1); /* value */
			}

			//lua_pop(L, 1); /* key */
		}
	}
#endif

  if (json)
    shjson_free(&json);

	/* return single boolean */
	lua_pushboolean(L, ret_bool);
	return (1);
}
Exemple #27
0
tx_asset_t *load_asset(shkey_t *asset_key)
{
  return ((tx_asset_t *)pstore_load(TX_ASSET, (char *)shkey_hex(asset_key)));
}
Exemple #28
0
int shfs_rev_commit(shfs_ino_t *file, shfs_ino_t **rev_p)
{
  shstat st;
  shbuf_t *diff_buff;
  shbuf_t *work_buff;
  shbuf_t *head_buff;
  shfs_ino_t *base;
  shfs_ino_t *repo; /* SHINODE_REPOSITORY */
  shfs_ino_t *new_rev; /* SHINODE_REVISION */
  shfs_ino_t *delta; /* SHINODE_DELTA */
  shkey_t *rev_key;
  shfs_t *fs;
  int err;

  if (rev_p)
    *rev_p = NULL;

  head_buff = work_buff = diff_buff = NULL;

  err = shfs_fstat(file, &st);
  if (err)
    return (err);

  work_buff = shbuf_init();
  err = shfs_read(file, work_buff); 
  if (err)
    goto done;

  base = shfs_rev_base(file);
  if (base) {
    /* obtain delta of current file data content against BASE revision's data content. */
    head_buff = shbuf_init();
    err = shfs_rev_ref_read(file, "tag", "BASE", head_buff);
    if (err)
      goto done;

    if (shbuf_size(work_buff) == shbuf_size(head_buff) &&
        0 == memcmp(shbuf_data(work_buff), shbuf_data(head_buff), shbuf_size(work_buff))) {
      /* no difference */
      err = SHERR_AGAIN;
      goto done;
    }

    diff_buff = shbuf_init();
    err = shdelta(work_buff, head_buff, diff_buff); 
    shbuf_free(&head_buff);
    if (err)
      return (err);

    rev_key = shfs_token(base);
  } else {
    /* initial revision */
    rev_key = ashkey_uniq();
  }

  repo = shfs_inode(file, NULL, SHINODE_REPOSITORY);
  if (!repo) {
    err = SHERR_IO;
    goto done;
  }

  /* create a new revision using previous revision's inode name */
  new_rev = shfs_inode(repo, (char *)shkey_hex(rev_key), SHINODE_REVISION); 
  if (!new_rev) {
    err = SHERR_IO;
    goto done;
  }

  /* define revision's meta information. */
  shfs_meta_set(new_rev, 
      SHMETA_USER_NAME, (char *)get_libshare_account_name());

  /* save delta to new revision */
  err = shfs_rev_delta_write(new_rev, diff_buff);
  shbuf_free(&diff_buff);
  if (err)
    goto done;


  /* save new revision as BASE branch head */
  err = shfs_rev_base_set(file, new_rev);
  if (err)
    goto done;

  /* save work-data to BASE tag. */
  err = shfs_rev_ref_write(file, "tag", "BASE", work_buff); 
  shbuf_free(&work_buff);
  if (err)
    goto done;

  if (base) {
    /* tag previous revision's key token onto revision inode. */
    shfs_rev_tag(new_rev, "PREV", base);
  }

  if (rev_p)
    *rev_p = new_rev;

done:
  shbuf_free(&work_buff);
  shbuf_free(&diff_buff);
  shbuf_free(&head_buff);

  return (err);
}