Shamir secret sharing and Lagrange interpolation (OpenSSL BIGNUM) - cryptography

Question

I've posted similar questions before, so i apologize in advance, but i'm just not able to find where i'm going wrong here.
I am implementing Shamir secret sharing using OpenSSL's BIGNUM library in C.
After i do a round of Lagrange interpolation, i multiply key * numerator and then i need to divide by the denominator.
Because there is no BN_mod_div function, i instead use BN_mod_inverse() on the denominator, then multiply, like so:
(key * numerator) * (inverse of denominator)
What i've noticed is that if i use BN_mod_inverse(denom, denom, q, ctx); then the value that should be inverted remains the same:
Round Key: 2E
Numerator: 14
Denominator: 6 **<---- ORIGINAL DENOMINATOR**
Multiply key with numerator: 398 (POSITIVE)
Invert Denominator: 6 (POSITIVE) **<---------- INVERSE IS THE SAME???**
(Key*Numerator)*inv.Denom: 3FC (POSITIVE)
Round Key: 562
Numerator: A
Denominator: -2
Multiply key with numerator: 118 (POSITIVE)
Invert Denominator: -2 (NEGATIVE)
(Key*Numerator)*inv.Denom: 3AC (POSITIVE)
Round Key: 5D1
Numerator: 8
Denominator: 3
Multiply key with numerator: 584 (POSITIVE)
Invert Denominator: 3 (POSITIVE)
(Key*Numerator)*inv.Denom: 4D4 (POSITIVE)
Recovered Key: C4 (POSITIVE)
Key should = 4D2
If I change that to BN_mod_inverse(newBN, denom, q, ctx); it just turns into a zero:
Round Key: 2E
Numerator: 14
Denominator: 6 **<---- ORIGINAL DENOMINATOR**
Multiply key with numerator: 398 (POSITIVE)
Invert Denominator: 0 (NEGATIVE) **<------------ DENOMINATOR IS NOW ZERO??**
(Key*Numerator)*inv.Denom: 0 (NEGATIVE)
Round Key: 562
Numerator: A
Denominator: -2
Multiply key with numerator: 118 (POSITIVE)
Invert Denominator: 0 (NEGATIVE)
(Key*Numerator)*inv.Denom: 0 (NEGATIVE)
Round Key: 5D1
Numerator: 8
Denominator: 3
Multiply key with numerator: 584 (POSITIVE)
Invert Denominator: 0 (NEGATIVE)
(Key*Numerator)*inv.Denom: 0 (NEGATIVE)
Recovered Key: 0 (NEGATIVE)
Key should = 4D2
In either case, the combined key is wrong. What's going on here? Is there a workaround for this?
Here is my code:
BIGNUM *int2BN(int i)
{
BIGNUM *tmp = BN_new();
BN_zero(tmp);
int g;
if(i < 0) { //If 'i' is negative
for (g = 0; g > i; g--) {
BN_sub(tmp, tmp, one);
}
} else { //If 'i' is positive
for (g = 0; g < i; g++) {
BN_add(tmp, tmp, one);
}
}
return(tmp);
}
static void
blah() {
int denomTmp, numTmp, numAccum, denomAccum;
int s, j;
BIGNUM *accum[3], *bnNum, *bnDenom;
bnNum = BN_new();
bnDenom = BN_new();
/* Lagrange Interpolation */
for (s = 0; s < 3; s++) {
numAccum = 1;
denomAccum = 1;
for (j = 0; j < 3; j++) {
if(s == j) continue;
else {
/* 0 - i[k] = numTmp */
numTmp = 0 - key[j].keynum;
/* share - i[k] = denomTmp */
denomTmp = key[s].keynum - key[j].keynum;
/* Numerator accumulation: */
numAccum *= numTmp;
/* Denominator accumulation: */
denomAccum *= denomTmp;
}
}
accum[s] = BN_new();
bnNum = int2BN(numAccum);
bnDenom = int2BN(denomAccum);
/* Multiply result by share */
BN_mod_mul(accum[s], key[s].key, bnNum, q, ctx);
/* Invert denominator */
BN_mod_inverse(bnDenom, bnDenom, q, ctx);
/* Multiply by inverted denominator */
BN_mod_mul(accum[s], accum[s], bnDenom, q, ctx);
}
int a;
BIGNUM *total = BN_new();
BN_zero(total);
for(a = 0; a < 3; a++) {
BN_mod_add(total, total, accum[a], q, ctx);
}
}

Answer 1

Use BN_div. The remainder is the modulo. That is, rem = a % d.
int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *a, const BIGNUM *d, BN_CTX *ctx);
BN_div() divides a by d and places the result in dv and the remainder in rem
(dv=a/d, rem=a%d). Either of dv and rem may be NULL, in which case the respective
value is not returned. The result is rounded towards zero; thus if a is negative,
the remainder will be zero or negative. For division by powers of 2, use
BN_rshift(3).