nthparty / oblivious Goto Github PK

This parts package is only required for testing, and is already implicitly required via the entry for bitlist that is found in the list of optional dependencies for testing.

When I try to find an inverse of a scalar, it doesn't work as expected while using the Oblivious.ristretto library.

I tried couple of variations to test out the discrepancy in the behavior.

Here are few of those instances:

#Some scalar s
s = scalar.hash("s".encode())

The scalars for which I am able to get an inverse:
~(s)
~(s * s)

But, if the scalar is of the form (s + s'), I am not able to get the inverse of it.
It throws - TypeError: bad operand type for unary ~: 'bytes'. I also tried using the inverse() method but that failed to work too.

Surprisingly, this error seems to be localised only within the Oblivious.ristretto library. The Oblivious.bn254 works well and behaves as expected.

We tested out these instances on google colab. Adding python code here for reference.

from oblivious.ristretto import point, scalar

s = scalar.hash(b"123")
m =  scalar.hash(b"456")

#Works
~(s)
~(s*s)

#Doesn't work
~(s+s)
~(s+m)

Do let me know if you need more context.

Implement additive Ristretto255 scalar group operations in oblivious.ristretto.scalar to match oblivious.bn254.scalar's arithmetic features, and possibly even scalar.from_int.

This discrepancy was first discussed in issue #8 as discovered by @rashmibhle.

Hi. I am looking for a library to implement the oblivious transfer.
The readme file says this library can be used to do so. But I do not know how to do it.
Is that possible to add some example code in the readme file or add an example folder with scripts implementing the OPRF, OT, and PSI?

Document the purpose of point.canonical(), performance benefit, equality of the bytes returned by point.to_bytes().

We just need to be clear that the bytes spit out (when you type a point variable into the interpreter, or print .to_bytes()) for p1 and p2 where p1 == p2 are not always the same.

Then, we can have .to_bytes(canonicalize=True) be the default and clarify that .to_bytes(canonicalize=False) is faster if you aren't doing byte-to-byte comparisons or other derivations directly from the bytes spit out.

Users of this library need to know that assert (p1.to_bytes() == p2.to_bytes()) == (p1 == p2) will sometimes fail, depending on how the points were computed (due to algorithms for computing point operations using optimizations such as using Jacobi coordinates x,y,z to represent points vs affine coordinates x,y and so on).