void
vg_exec_context_calc_address(vg_exec_context_t *vxcp)
{
EC_POINT *pubkey;
const EC_GROUP *pgroup;
unsigned char eckey_buf[96], hash1[32], hash2[20];
int len;
vg_exec_context_consolidate_key(vxcp);
pgroup = EC_KEY_get0_group(vxcp->vxc_key);
pubkey = EC_POINT_new(pgroup);
EC_POINT_copy(pubkey, EC_KEY_get0_public_key(vxcp->vxc_key));
if (vxcp->vxc_vc->vc_pubkey_base) {
EC_POINT_add(pgroup,
pubkey,
pubkey,
vxcp->vxc_vc->vc_pubkey_base,
vxcp->vxc_bnctx);
}
len = EC_POINT_point2oct(pgroup,
pubkey,
POINT_CONVERSION_UNCOMPRESSED,
eckey_buf,
sizeof(eckey_buf),
vxcp->vxc_bnctx);
SHA256(eckey_buf, len, hash1);
RIPEMD160(hash1, sizeof(hash1), hash2);
memcpy(&vxcp->vxc_binres[1],
hash2, 20);
EC_POINT_free(pubkey);
}
static int
vg_prefix_test(vg_exec_context_t *vxcp)
{
vg_prefix_context_t *vcpp = (vg_prefix_context_t *) vxcp->vxc_vc;
vg_prefix_t *vp;
int res = 0;
/*
* We constrain the prefix so that we can check for
* a match without generating the lower four byte
* check code.
*/
BN_bin2bn(vxcp->vxc_binres, 25, &vxcp->vxc_bntarg);
research:
vp = vg_prefix_avl_search(&vcpp->vcp_avlroot, &vxcp->vxc_bntarg);
if (vp) {
if (vg_exec_context_upgrade_lock(vxcp))
goto research;
vg_exec_context_consolidate_key(vxcp);
// vcpp->base.vc_output_match(&vcpp->base, vxcp->vxc_key,
// vp->vp_pattern, &combined_compressed);
vcpp->base.vc_output_match(&vcpp->base, vxcp,
vp->vp_pattern);
vcpp->base.vc_found++;
if (vcpp->base.vc_only_one) {
return 2;
}
if (vcpp->base.vc_remove_on_match) {
/* Subtract the range from the difficulty */
vg_prefix_range_sum(vp,
&vxcp->vxc_bntarg,
&vxcp->vxc_bntmp);
BN_sub(&vxcp->vxc_bntmp,
&vcpp->vcp_difficulty,
&vxcp->vxc_bntarg);
BN_copy(&vcpp->vcp_difficulty, &vxcp->vxc_bntmp);
vg_prefix_delete(&vcpp->vcp_avlroot,vp);
vcpp->base.vc_npatterns--;
if (!avl_root_empty(&vcpp->vcp_avlroot))
vg_prefix_context_next_difficulty(
vcpp, &vxcp->vxc_bntmp,
&vxcp->vxc_bntmp2,
vxcp->vxc_bnctx);
vcpp->base.vc_pattern_generation++;
}
res = 1;
}
if (avl_root_empty(&vcpp->vcp_avlroot)) {
return 2;
}
return res;
}
static int
vg_regex_test(vg_exec_context_t *vxcp)
{
vg_regex_context_t *vcrp = (vg_regex_context_t *) vxcp->vxc_vc;
unsigned char hash1[32], hash2[32];
int i, zpfx, p, d, nres, re_vec[9];
char b58[40];
BIGNUM bnrem;
BIGNUM *bn, *bndiv, *bnptmp;
int res = 0;
pcre *re;
BN_init(&bnrem);
/* Hash the hash and write the four byte check code */
SHA256(vxcp->vxc_binres, 21, hash1);
SHA256(hash1, sizeof(hash1), hash2);
memcpy(&vxcp->vxc_binres[21], hash2, 4);
bn = &vxcp->vxc_bntmp;
bndiv = &vxcp->vxc_bntmp2;
BN_bin2bn(vxcp->vxc_binres, 25, bn);
/* Compute the complete encoded address */
for (zpfx = 0; zpfx < 25 && vxcp->vxc_binres[zpfx] == 0; zpfx++);
p = sizeof(b58) - 1;
b58[p] = '\0';
while (!BN_is_zero(bn)) {
BN_div(bndiv, &bnrem, bn, &vxcp->vxc_bnbase, vxcp->vxc_bnctx);
bnptmp = bn;
bn = bndiv;
bndiv = bnptmp;
d = BN_get_word(&bnrem);
b58[--p] = vg_b58_alphabet[d];
}
while (zpfx--) {
b58[--p] = vg_b58_alphabet[0];
}
/*
* Run the regular expressions on it
* SLOW, runs in linear time with the number of REs
*/
restart_loop:
nres = vcrp->base.vc_npatterns;
if (!nres) {
res = 2;
goto out;
}
for (i = 0; i < nres; i++) {
d = pcre_exec(vcrp->vcr_regex[i],
vcrp->vcr_regex_extra[i],
&b58[p], (sizeof(b58) - 1) - p, 0,
0,
re_vec, sizeof(re_vec)/sizeof(re_vec[0]));
if (d <= 0) {
if (d != PCRE_ERROR_NOMATCH) {
fprintf(stderr, "PCRE error: %d\n", d);
res = 2;
goto out;
}
continue;
}
re = vcrp->vcr_regex[i];
if (vg_exec_context_upgrade_lock(vxcp) &&
((i >= vcrp->base.vc_npatterns) ||
(vcrp->vcr_regex[i] != re)))
goto restart_loop;
vg_exec_context_consolidate_key(vxcp);
vcrp->base.vc_output_match(&vcrp->base, vxcp->vxc_key,
vcrp->vcr_regex_pat[i]);
vcrp->base.vc_found++;
if (vcrp->base.vc_only_one) {
res = 2;
goto out;
}
if (vcrp->base.vc_remove_on_match) {
pcre_free(vcrp->vcr_regex[i]);
if (vcrp->vcr_regex_extra[i])
pcre_free(vcrp->vcr_regex_extra[i]);
nres -= 1;
vcrp->base.vc_npatterns = nres;
if (!nres) {
res = 2;
goto out;
}
vcrp->vcr_regex[i] = vcrp->vcr_regex[nres];
vcrp->vcr_regex_extra[i] =
vcrp->vcr_regex_extra[nres];
vcrp->vcr_regex_pat[i] = vcrp->vcr_regex_pat[nres];
vcrp->base.vc_npatterns = nres;
vcrp->base.vc_pattern_generation++;
}
res = 1;
}
out:
BN_clear_free(&bnrem);
return res;
}