| | |
- builtins.object
-
- Party
- Runtime
class Party(builtins.object) |
| |
Party(pid: int, host: str = None, port: int = None) -> None
Information about party with identity pid in the MPC protocol.
|
| |
Methods defined here:
- __eq__(self, other)
- Return self==value.
- __init__(self, pid: int, host: str = None, port: int = None) -> None
- Initialize self. See help(type(self)) for accurate signature.
- __repr__(self)
- String representation of the party.
Data descriptors defined here:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
Data and other attributes defined here:
- __annotations__ = {'host': <class 'str'>, 'pid': <class 'int'>, 'port': <class 'int'>}
- __dataclass_fields__ = {'host': Field(name='host',type=<class 'str'>,default=Non...appingproxy({}),kw_only=False,_field_type=_FIELD), 'pid': Field(name='pid',type=<class 'int'>,default=<dat...appingproxy({}),kw_only=False,_field_type=_FIELD), 'port': Field(name='port',type=<class 'int'>,default=Non...appingproxy({}),kw_only=False,_field_type=_FIELD)}
- __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,order=False,unsafe_hash=False,frozen=False)
- __hash__ = None
- __match_args__ = ('pid', 'host', 'port')
- host = None
- port = None
- protocol = None
|
class Runtime(builtins.object) |
| |
Runtime(pid, parties, options)
MPyC runtime secure against passive attacks.
The runtime maintains basic information such as a program counter, the list
of parties, etc., and handles secret-shared objects of type SecureObject.
1-party case is supported (with option to disable asynchronous evaluation).
Threshold 0 (no corrupted parties) is supported for m-party case as well
to enable distributed computation (without secret sharing).
|
| |
Methods defined here:
- async __aenter__(self)
- Start MPyC runtime when entering async with context.
- async __aexit__(self, exc_type, exc, tb)
- Shutdown MPyC runtime when exiting async with context.
- __init__(self, pid, parties, options)
- Initialize runtime.
- abs(self, a, l=None)
- Secure absolute value of a.
- add(self, a, b)
- Secure addition of a and b.
- add_bits(self, x, y)
- Secure binary addition of bit vectors x and y.
- all(self, x)
- Secure all of elements in x, similar to Python's built-in all().
Elements of x are assumed to be either 0 or 1 (Boolean).
Runs in log_2 len(x) rounds.
- and_(self, a, b)
- Secure bitwise and of a and b.
- any(self, x)
- Secure any of elements in x, similar to Python's built-in any().
Elements of x are assumed to be either 0 or 1 (Boolean).
Runs in log_2 len(x) rounds.
- argmax(self, *x, key=None)
- Secure argmax of all given elements in x.
See runtime.sorted() for details on key etc.
In case of multiple occurrences of the maximum values,
the index of the first occurrence is returned.
- argmin(self, *x, key=None)
- Secure argmin of all given elements in x.
See runtime.sorted() for details on key etc.
In case of multiple occurrences of the minimum values,
the index of the first occurrence is returned.
- async barrier(self, name=None)
- Barrier for runtime, using optional string name for easy identification.
- convert(self, x, t_type)
- Secure conversion of (elements of) x to given t_type.
Value x is a secure number, or a list of secure numbers.
Converted values assumed to fit in target type.
- cos(self, a)
- Secure cosine of fixed-point number a.
- div(self, a, b)
- Secure division of a by b, for nonzero b.
- eq(self, a, b)
- Secure comparison a == b.
- eq_public(self, a, b)
- Secure public equality test of a and b.
- find(self, x, a, bits=True, e='len(x)', f=None, cs_f=None)
- Return index ix of the first occurrence of a in list x.
The elements of x and a are assumed to be in {0, 1}, by default.
Set Boolean flag bits=False for arbitrary inputs.
If a is not present in x, then ix=len(x) by default.
Set flag e=E to get ix=E instead if a is not present in x.
Set e=None to get the "raw" output as a pair (nf, ix), where
the indicator bit nf=1 if and only if a is not found in x.
For instance, E=-1 can be used to mimic Python's find() methods.
If E is a string, i=eval(E) will be returned where E is an expression
in terms of len(x). As a simple example, E='len(x)-1' will enforce
that a is considered to be present in any case as the last element
of x, if not earlier.
The return value is index ix, by default.
If function f is set, the value of f(ix) is returned instead.
Even though index ix is a secure number, however, the computation of f(ix)
does not incur any communication costs, requiring local computation only.
For example, with f=lambda i: 2^i we would save the work for a secure
exponentiation, which would otherwise require a call to runtime.to_bits(ix), say.
Also, function cs_f can be set instead of specifying function f directly.
Function cs_f(b, i) will take as input a (secure) bit b and a (public) index i.
The relationship between function f and its "conditional-step function" cs_f
is given by:
cs_f(b, i) = f(i+b), for b in {0, 1} (*)
For example, for f(i) = i, we get cs_f(b, i) = i+b.
And, for f(i) = 2^i, we get cs_f(b, i) = 2^(i+b) = (b+1) 2^i.
In general, we have:
cs_f(b, i) = b (f(i+1) - f(i)) + f(i), for b in {0, 1} (**)
For this reason, cs_f(b, i) can be computed locally indeed.
A few more examples:
f(i) = i | 2^i | n-i | 2^-i | (i, 2^i)
cs_f(b, i) = i+b | (b+1) 2^i | n-i-b | (2-b) 2^-(i+1) | (i+b, (b+1) 2^i)
In the last example, f(i) is a tuple containing two values. In general, f(i)
can be a single number or a tuple/list of numbers.
Note that it suffices to specify either f or cs_f, as (*) implies that
f(i) = cs_f(0, i). If cs_f is not set, it will be computed from f using (**),
incurring some overhead.
- from_bits(self, x)
- Recover secure number from its binary representation x.
- gather = gather_shares(rt, *obj)
- Gather all results for the given futures (shares).
- gauss(self, A, d, b, c)
- Secure Gaussian elimination A d - b c.
- gcd(self, a, b, l=None)
- Secure greatest common divisor of a and b.
If provided, l should be an upper bound on the bit lengths of both a and b.
- gcdext(self, a, b, l=None)
- Secure extended GCD of secure integers a and b.
Return triple (g, s, t) such that g = gcd(a,b) = s*a + t*b.
If provided, l should be an upper bound on the bit lengths of a and b.
- gcp2(self, a, b, l=None)
- Secure greatest common power of 2 dividing a and b.
- ge(self, a, b)
- Secure comparison a >= b.
- if_else(self, c, x, y)
- Secure selection between x and y based on condition c.
- if_swap(self, c, x, y)
- Secure swap of x and y based on condition c.
- in_prod(self, x, y)
- Secure dot product of x and y (one resharing).
- indexOf(self, x, a, bits=False)
- Return index of the first occurrence of a in x.
Raise ValueError if a is not present.
- input(self, x, senders=None)
- Input x to the computation.
Value x is a secure object, or a list of secure objects.
The senders are the parties that provide an input.
The default is to let every party be a sender.
Except for secure integers, secure fixed-point numbers, and
secure finite field elements, which are handled directly, the
input of secure objects is controlled by their _input() method.
For instance, mpyc.sectypes.SecureFloat._input() does this for
secure floating-point numbers.
- inverse(self, a, b, l=None)
- Secure inverse of a modulo b, assuming a>=0, b>0, and gcd(a,b)=1.
The result is nonnegative and less than b (inverse is 0 only when b=1).
If provided, l should be an upper bound on the bit lengths of both a and b.
To compute inverses for negative b, use -b instead of b, and
to compute inverses for arbitrary nonzero b, use abs(b) instead of b.
- invert(self, a)
- Secure bitwise inverse (not) of a.
- is_zero(self, a)
- Secure zero test a == 0.
- is_zero_public(self, a) -> _asyncio.Future
- Secure public zero test of a.
- lcm(self, a, b, l=None)
- Secure least common multiple of a and b.
If provided, l should be an upper bound on the bit lengths of both a and b.
- logging(self, enable=None)
- Toggle/enable/disable logging.
- lsb(self, a)
- Secure least significant bit of a.
- lt(self, a, b)
- Secure comparison a < b.
- matrix_add(self, A, B, tr=False)
- Secure addition of matrices A and (transposed) B.
- matrix_prod(self, A, B, tr=False)
- Secure matrix product of A with (transposed) B.
- matrix_sub(self, A, B, tr=False)
- Secure subtraction of matrices A and (transposed) B.
- max(self, *x, key=None)
- Secure maximum of all given elements in x, similar to Python's built-in max().
See runtime.sorted() for details on key etc.
- min(self, *x, key=None)
- Secure minimum of all given elements in x, similar to Python's built-in min().
See runtime.sorted() for details on key etc.
- min_max(self, *x, key=None)
- Secure minimum and maximum of all given elements in x.
Saves 25% compared to calling min(x) and max(x) separately.
Total number of comparisons is only (3n-3)//2, compared to 2n-2 for the obvious approach.
This is optimal as shown by Ira Pohl in "A sorting problem and its complexity",
Communications of the ACM 15(6), pp. 462-464, 1972.
- mod(self, a, b)
- Secure modulo reduction.
- mul(self, a, b)
- Secure multiplication of a and b.
- neg(self, a)
- Secure negation (additive inverse) of a.
- np_absolute(self, a, l=None)
- Secure elementwise absolute value of a.
- np_add(self, a, b)
- Secure addition of a and b, elementwise with broadcast.
- np_all(self, a, axis=None)
- Secure all-predicate for array a, entirely or along the given axis (or axes).
If axis is None (default) all is evaluated over the entire array (returning a scalar).
If axis is an int or a tuple of ints, all is evaluated along all specified axes.
The shape of the result is the shape of a with all specified axes removed
(converted to a scalar if no dimensions remain).
- np_amax(self, a, axis=None, keepdims=False)
- Secure maximum of array a, entirely or along the given axis (or axes).
If axis is None (default) the maximum of the array is returned.
If axis is an int or a tuple of ints, the minimum along all specified axes is returned.
If keepdims is not set (default), the shape of the result is the shape of a with all
specified axes removed (converted to a scalar if no dimensions remain).
Otherwise, if keepdims is set, the axes along which the maximum is taken
are left in the result as dimensions of size 1.
- np_amin(self, a, axis=None, keepdims=False)
- Secure minimum of array a, entirely or along the given axis (or axes).
If axis is None (default) the minimum of the array is returned.
If axis is an int or a tuple of ints, the minimum along all specified axes is returned.
If keepdims is not set (default), the shape of the result is the shape of a with all
specified axes removed (converted to a scalar if no dimensions remain).
Otherwise, if keepdims is set, the axes along which the minimum is taken
are left in the result as dimensions of size 1.
- np_any(self, a, axis=None)
- Secure any-predicate for array a, entirely or along the given axis (or axes).
If axis is None (default) any is evaluated over the entire array (returning a scalar).
If axis is an int or a tuple of ints, any is evaluated along all specified axes.
The shape of the result is the shape of a with all specified axes removed
(converted to a scalar if no dimensions remain).
- np_append(self, arr, values, axis=None)
- Append values to the end of array arr.
If axis is None (default), arr and values are flattened first.
Otherwise, arr and values must all be of the same shape, except along the given axis.
- np_argmax(self, a, axis=None, keepdims=False, key=None, arg_unary=False, arg_only=True)
- Returns the indices of the maximum values along an axis.
Default behavior similar to np.argmax() for NumPy arrays:
- the indices are returned as numbers (not as unit vectors),
- only the indices are returned (maximum values omitted).
NB: Different defaults than for method call a.argmax().
If no axis is given (default), array a is flattened first.
If the indices are returned as unit vectors in an array u say,
then u is always of the same shape as the (possibly flattened) input array a.
If the indices are returned as numbers, the shape of the array of indices
is controlled by parameter keepdims. If keepdims is not set (default),
the shape of the indices is the shape of a with the specified axis removed
(converted to a scalar if no dimensions remain). Otherwise, if keepdims is
set, the axis along which the maximum is taken is left in the result as
dimension of size 1.
If the maximum values are returned as well, the shape of this part of the output is
also controlled by parameter keepdims. If keepdims is not set (default), a 1D array
of maximum values is returned with one entry per element of the given array a with
the given axis removed; if axis is None, the maximum is returned as a scalar.
Otherwise, if keepdims is set, the array of maximum values is of the same shape
as the given array a except that the dimension of the given axis is reduced to 1;
if axis is None, all axes are present as dimensions of size 1.
- np_argmin(self, a, axis=None, keepdims=False, key=None, arg_unary=False, arg_only=True)
- Returns the indices of the minimum values along an axis.
Default behavior similar to np.argmin() for NumPy arrays:
- the indices are returned as numbers (not as unit vectors),
- only the indices are returned (minimum values omitted).
NB: Different defaults than for method call a.argmin().
If no axis is given (default), array a is flattened first.
If the indices are returned as unit vectors in an array u say,
then u is always of the same shape as the (possibly flattened) input array a.
If the indices are returned as numbers, the shape of the array of indices
is controlled by parameter keepdims. If keepdims is not set (default),
the shape of the indices is the shape of a with the specified axis removed
(converted to a scalar if no dimensions remain). Otherwise, if keepdims is
set, the axis along which the minimum is taken is left in the result as
dimension of size 1.
If the minimum values are returned as well, the shape of this part of the output is
also controlled by parameter keepdims. If keepdims is not set (default), a 1D array
of minimum values is returned with one entry per element of the given array a with
the given axis removed; if axis is None, the minimum is returned as a scalar.
Otherwise, if keepdims is set, the array of minimum values is of the same shape
as the given array a except that the dimension of the given axis is reduced to 1;
if axis is None, all axes are present as dimensions of size 1.
- np_block(self, arrays)
- Assemble an array from nested lists of blocks given by arrays.
Blocks in the innermost lists are concatenated along the last axis,
then these are concatenated along the second to last axis,
and so on until the outermost list is reached.
- np_column_stack(self, tup)
- np_concatenate(self, arrays, axis=0)
- Join a sequence of arrays along an existing axis.
If axis is None, arrays are flattened before use.
Default axis is 0.
- np_copy(self, a, order='K')
- np_det(self, A)
- Secure determinant for nonsingular matrices.
- np_divide(self, a, b)
- Secure division of a and b, for nonzero b, elementwise with broadcast.
- np_dsplit(self, ary, indices_or_sections)
- Split array into multiple sub-arrays along the 3rd axis (depth).
- np_dstack(self, tup)
- Stack arrays in sequence depth wise (along third axis).
This is equivalent to concatenation along the third axis
after 2D arrays of shape (M,N) have been reshaped to
(M,N,1) and 1D arrays of shape (N,) have been reshaped
to (1,N,1). Rebuilds arrays divided by dsplit.
- np_equal(self, a, b)
- Secure comparison a == b, elementwise with broadcast.
- np_flatten(self, a, order='C')
- Return 1D copy of a.
Default 'C' for row-major order (C style).
Alternative 'F' for column-major order (Fortran style).
- np_fliplr(self, a)
- Reverse the order of elements along axis 1 (left/right).
For a 2D array, this flips the entries in each row in the left/right direction.
Columns are preserved, but appear in a different order than before.
- np_from_bits(self, x)
- Recover secure numbers from their binary representations in x.
- np_fromlist(self, x)
- List of secure numbers to 1D array.
- np_getitem(self, a, key)
- Secure array a, index/slice key.
- np_hsplit(self, ary, indices_or_sections)
- Split an array into multiple sub-arrays horizontally (column-wise).
- np_hstack(self, tup)
- Stack arrays in sequence horizontally (column wise).
This is equivalent to concatenation along the second axis,
except for 1D arrays where it concatenates along the first
axis. Rebuilds arrays divided by hsplit.
- np_is_zero_public(self, a) -> _asyncio.Future
- Secure public zero test of a, elementwise.
- np_less(self, a, b)
- Secure comparison a < b, elementwise with broadcast.
- np_matmul(self, A, B)
- Secure matrix product of arrays A and B, with broadcast.
- np_maximum(self, a, b)
- Secure elementwise maximum of a and b.
If a and b are of different shapes, they must be broadcastable to a common shape
(which is scalar if both a and b are scalars).
- np_minimum(self, a, b)
- Secure elementwise minimum of a and b.
If a and b are of different shapes, they must be broadcastable to a common shape
(which is scalar if both a and b are scalars).
- np_multiply(self, a, b)
- Secure multiplication of a and b, elementwise with broadcast.
- np_negative(self, a)
- Secure elementwise negation -a (additive inverse) of a.
- np_outer(self, a, b)
- Secure outer product of vectors a and b.
Input arrays a and b are flattened if not already 1D.
- np_pow(self, a, b)
- Secure elementwise exponentiation a raised to the power of b, for public integer b.
- np_prod(self, a, axis=None)
- Secure product of array elements over a given axis (or axes).
- np_random_bits(self, sftype, n, signed=False)
- Return shape-(n,) secure array with uniformly random bits of given type.
- np_reciprocal(self, a)
- Secure elementwise reciprocal (multiplicative field inverse) of a, for nonzero a.
- np_reshape(self, a, shape, order='C')
- np_roll(self, a, shift, axis=None)
- Roll array elements (cyclically) along a given axis.
If axis is None (default), array is flattened before cyclic shift,
and original shape is restored afterwards.
- np_row_stack = np_vstack(self, tup)
- np_sgn(self, a, l=None, LT=False, EQ=False)
- Secure elementwise sign(um) of array a.
Return -1 if a < 0 else 0 if a == 0 else 1.
If integer flag l=L is set, it is assumed that -2^(L-1) <= a < 2^(L-1)
to save work (compared to the default l=type(a).bit_length).
If Boolean flag LT is set, perform a secure less than zero test instead, and
return 1 if a < 0 else 0, saving the work for a secure equality test.
If Boolean flag EQ is set, perform a secure equal to zero test instead, and
return 1 if a == 0 else 0, saving the work for a secure comparison.
- np_sort(self, a, axis=-1, key=None)
- "Returns new array sorted along given axis.
By default, axis=-1.
If axis is None, the array is flattened.
Same sorting network as in self._sort().
- np_split(self, ary, indices_or_sections, axis=0)
- Split an array into multiple sub-arrays as views into ary.
- np_stack(self, arrays, axis=0)
- Join a sequence of arrays along a new axis.
The axis parameter specifies the index of the new axis in the shape of the result.
For example, if axis=0 it will be the first dimension and if axis=-1 it will be
the last dimension.
- np_subtract(self, a, b)
- Secure subtraction of a and b, elementwise with broadcast.
- np_sum(self, a, axis=None, keepdims=False, initial=0)
- Secure sum of array elements over a given axis (or axes).
- np_swapaxes(self, a, axis1, axis2)
- Interchange two given axes of array a.
For 2D arrays, same as the usual matrix transpose.
- np_to_bits(self, a, l=None)
- Secure extraction of l (or all) least significant bits of a.
- np_tolist(self, a)
- Return array a as an nested list of Python scalars.
The nested list is a.ndim levels deep (scalar if a.ndim is zero).
- np_transpose(self, a, axes=None)
- Reverse (default) or permute the axes of array a.
For 2D arrays, default result is the usual matrix transpose.
Parameter axes can be any permutation of 0,...,n-1 for n-dimensional array a.
- np_trunc(self, a, f=None, l=None)
- Secure truncation of f least significant bits of (elements of) a.
Probabilistic rounding of a / 2**f (elementwise).
- np_unit_vector(self, a, n)
- Length-n unit vector [0]*a + [1] + [0]*(n-1-a) for secret a, assuming 0 <= a < n.
Unit vector returned as secure NumPy array.
NB: Value of a is reduced modulo n (almost for free).
- np_update(self, a, key, value)
- Return secure array modified by update a[key]=value.
Also value can be a secure array or object.
But key is in the clear.
Differs from __setitem__() which works in-place, returning None.
MUST be used as follows: a = np_update(a, key, value).
- np_vsplit(self, ary, indices_or_sections)
- Split an array into multiple sub-arrays vertically (row-wise).
- np_vstack(self, tup)
- np_where(self, c, a, b)
- Return elements chosen from a or b depending on condition c.
The shapes of a, b, and c are broadcast together.
- or_(self, a, b)
- Secure bitwise or of a and b.
- output(self, x, receivers=None, threshold=None, raw=False)
- Output the value of x to the receivers specified.
Value x is a secure object, or a list of secure objects.
The receivers are the parties that will obtain the output.
The default is to let every party be a receiver.
A secure integer is output as a Python int, a secure
fixed-point number is output as a Python float, and a secure
finite field element is output as an MPyC finite field element.
Set flag raw=True to suppress output conversion.
For all other types of secure objects their _output() method controls
what is output. For instance, mpyc.sectypes.SecureFloat._output()
outputs secure floating-point numbers as Python floats.
The flag raw is ignored for these types.
- pos(self, a)
- Secure unary + applied to a.
- pow(self, a, b)
- Secure exponentiation a raised to the power of b, for public integer b.
- prfs(self, bound)
- PRFs with codomain range(bound) for pseudorandom secret sharing.
Return a mapping from sets of parties to PRFs.
- prod(self, x, start=1)
- Secure product of all elements in x, similar to Python's math.prod().
Runs in log_2 len(x) rounds).
- random_bit(self, stype, signed=False)
- Secure uniformly random bit of the given type.
- random_bits(self, sftype, n, signed=False)
- Return n secure uniformly random bits of the given type.
- reciprocal(self, a)
- Secure reciprocal (multiplicative field inverse) of a, for nonzero a.
- run(self, f)
- Run the given coroutine or future until it is done.
- scalar_mul(self, a, x)
- Secure scalar multiplication of scalar a with vector x.
- schur_prod(self, x, y)
- Secure entrywise multiplication of vectors x and y.
- set_protocol(self, peer_pid, protocol)
- sgn(self, a, l=None, LT=False, EQ=False)
- Secure sign(um) of a, return -1 if a < 0 else 0 if a == 0 else 1.
If integer flag l=L is set, it is assumed that -2^(L-1) <= a < 2^(L-1)
to save work (compared to the default l=type(a).bit_length).
If Boolean flag LT is set, perform a secure less than zero test instead, and
return 1 if a < 0 else 0, saving the work for a secure equality test.
If Boolean flag EQ is set, perform a secure equal to zero test instead, and
return 1 if a == 0 else 0, saving the work for a secure comparison.
- async shutdown(self)
- Shutdown the MPyC runtime.
Close all connections, if any.
- sin(self, a)
- Secure sine of fixed-point number a.
- sincos(self, a)
- Secure sine and cosine of fixed-point number a.
See "New Approach for Sine and Cosine in Secure Fixed-Point Arithmetic"
by Stan Korzilius and Berry Schoenmakers, which appeared in the proceedings
of CSCML 2023, 7th International Symposium on Cyber Security, Cryptology
and Machine Learning, LNCS 13914, pp. 307-319, Springer (see
https://doi.org/10.1007/978-3-031-34671-2).
- sorted(self, x, key=None, reverse=False)
- Return a new securely sorted list with elements from x in ascending order.
Similar to Python's built-in sorted(), but not stable.
Elements of x are either secure numbers or lists of secure numbers.
Argument key specifies a function applied to all elements of x before comparing them, using
only < comparisons (that is, using only the __lt__() method, as for Python's list.sort()).
Default key compares elements of x directly (using identity function 'lambda a: a').
- async start(self)
- Start the MPyC runtime.
Open connections with other parties, if any.
- sub(self, a, b)
- Secure subtraction of a and b.
- sum(self, x, start=0)
- Secure sum of all elements in x, similar to Python's built-in sum().
- tan(self, a)
- Secure tangent of fixed-point number a.
- async throttler(self, load_percentage=1.0, name=None)
- Throttle runtime by given percentage (default 1.0), using optional name for barrier.
- to_bits(self, a, l=None)
- Secure extraction of l (or all) least significant bits of a.
- trailing_zeros(self, a, l=None)
- Secure extraction of l least significant (or all) bits of a,
only correct up to and including the least significant 1 (if any).
- transfer(self, obj, senders=None, receivers=None, sender_receivers=None) -> _asyncio.Future
- Transfer pickable Python objects between specified parties.
The senders are the parties that provide input.
The receivers are the parties that will obtain output.
The default is to let every party be a sender as well as a receiver.
The (directed) communication graph specifying which parties sends their message
given as obj to which receivers is represented by:
- either the senders/receivers arguments for a complete bipartite graph,
- or the sender_receivers argument for an arbitrary graph.
Each party i corresponds to a node in the communication graph.
The senders/receivers arguments represent subsets of nodes, in the form
of a list, a Python range object, or a Python int.
The sender_receivers argument represents a set of arcs, in the form of a
list of node pairs or as a Python dict mapping nodes to subsets of nodes.
- trunc(self, x, f=None, l=None)
- Secure truncation of f least significant bits of (elements of) x.
Probabilistic rounding of a / 2**f for a in x.
- unit_vector(self, a, n)
- Length-n unit vector [0]*a + [1] + [0]*(n-1-a) for secret a, assuming 0 <= a < n.
NB: If a = n, unit vector [1] + [0]*(n-1) is returned. See mpyc.statistics.
- unset_protocol(self, peer_pid)
- vector_add(self, x, y)
- Secure addition of vectors x and y.
- vector_sub(self, x, y)
- Secure subtraction of vectors x and y.
- xor(self, a, b)
- Secure bitwise xor of a and b.
Static methods defined here:
- SecClassGroup(Delta=None, l=None)
- Call SecClassGroup(...) is equivalent to SecGrp(ClassGroup(...)),
returning secure version of ClassGroup from mpyc.fingroups.
ClassGroup(Delta=None, l=None):
Create type for class group, given (bit length l of) discriminant Delta.
The following conditions are imposed on discriminant Delta:
- Delta < 0, only supporting class groups of imaginary quadratic field
- Delta = 1 (mod 4), preferably Delta = 1 (mod 8)
- -Delta is prime
This implies that Delta is a fundamental discriminant.
- SecEllipticCurve(curvename='Ed25519', coordinates=None)
- Call SecEllipticCurve(...) is equivalent to SecGrp(EllipticCurve(...)),
returning secure version of EllipticCurve from mpyc.fingroups.
EllipticCurve(curvename='Ed25519', coordinates=None):
Create elliptic curve type for a selection of built-in curves.
The default coordinates used with these curves are 'affine'.
The following Edwards curves and Weierstrass curves are built-in:
- 'Ed25519': see https://en.wikipedia.org/wiki/EdDSA#Ed25519
- 'Ed448': aka "Goldilocks", see https://en.wikipedia.org/wiki/Curve448
- 'secp256k1': Bitcoin's Koblitz curve from https://www.secg.org/sec2-v2.pdf
- 'BN256': Barreto-Naehrig curve, https://eprint.iacr.org/2010/186
- 'BN256_twist': sextic twist of Barreto-Naehrig curve
These curves can be used with 'affine' (default) and 'projective' coordinates.
The Edwards curves can also be used with 'extended' coordinates, and the
Weierstrass curves with 'jacobian' coordinates.
- SecFld(order=None, modulus=None, char=None, ext_deg=None, min_order=None, signed=False)
- Secure finite field of order q = p**d.
Order q >= min_order.
Field is prime (d = 1) by default and if modulus is prime.
Extension degree d > 1 if order is a prime power p**d with d > 1,
if modulus is a polynomial or a string or an integer > char,
or if ext_deg is an integer > 1, or if min_order > char.
- SecFlt(l=None, s=None, e=None)
- Secure l-bit floating-point number with s-bit significand and e-bit exponent, where l=s+e.
The significand is an (s+1)-bit secure (signed) fixed-point number. The absolute value
of a nonzero significand is normalized between 0.5 and 1.0. Here, both 0.5 and 1.0 are
included and therefore one extra bit is used.
The exponent is an e-bit secure (signed) integer.
- SecFxp(l=None, f=None, p=None, n=2)
- Secure l-bit fixed-point numbers with f-bit fractional part.
NB: if dividing secure fixed-point numbers, make sure that l =~ 2f.
- SecGrp(group)
- Secure version of given finite group.
- SecInt(l=None, p=None, n=2)
- Secure l-bit integers.
- SecQuadraticResidues(p=None, l=None)
- Call SecQuadraticResidues(...) is equivalent to SecGrp(QuadraticResidues(...)),
returning secure version of QuadraticResidues from mpyc.fingroups.
QuadraticResidues(p=None, l=None):
Create type for quadratic residues group given (bit length l of) odd prime modulus p.
The group of quadratic residues modulo p is of order n=(p-1)/2.
Given bit length l>2, p will be chosen such that n is also an odd prime.
If l=2, the only possibility is p=3, hence n=1.
- SecSchnorrGroup(p=None, q=None, g=None, l=None, n=None)
- Call SecSchnorrGroup(...) is equivalent to SecGrp(SchnorrGroup(...)),
returning secure version of SchnorrGroup from mpyc.fingroups.
SchnorrGroup(p=None, q=None, g=None, l=None, n=None):
Create type for Schnorr group of odd prime order q.
If q is not given, q will be the largest n-bit prime, n>=2.
If p is not given, p will be the least l-bit prime, l>n, such that q divides p-1.
If l and/or n are not given, default bit lengths will be set (2<=n<l).
- SecSymmetricGroup(n)
- Call SecSymmetricGroup(...) is equivalent to SecGrp(SymmetricGroup(...)),
returning secure version of SymmetricGroup from mpyc.fingroups.
SymmetricGroup(n):
Create type for symmetric group of degree n, n>=0.
- coroutine = mpc_coro(func, pc=True)
- Decorator turning coroutine func into an MPyC coroutine.
An MPyC coroutine is evaluated asynchronously, returning empty placeholders.
The type of the placeholders is defined either by a return annotation
of the form "-> expression" or by the first await expression in func.
Return annotations can only be used for static types.
- returnType(*args, wrap=True)
- Define return type for MPyC coroutines.
Used in first await expression in an MPyC coroutine.
Data descriptors defined here:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
- threshold
- Threshold for MPC.
Data and other attributes defined here:
- SecureArray = <class 'mpyc.sectypes.SecureArray'>
- Base class for secure (secret-shared) number arrays.
- SecureFiniteField = <class 'mpyc.sectypes.SecureFiniteField'>
- Base class for secure (secret-shared) finite field elements.
NB: bit-oriented operations will be supported for prime fields.
- SecureFiniteFieldArray = <class 'mpyc.sectypes.SecureFiniteFieldArray'>
- Base class for secure (secret-shared) arrays of finite field elements.
- SecureFiniteGroup = <class 'mpyc.secgroups.SecureFiniteGroup'>
- Abstract base class for secure (secret-shared) finite groups elements.
- SecureFixedPoint = <class 'mpyc.sectypes.SecureFixedPoint'>
- Base class for secure (secret-shared) fixed-point numbers.
- SecureFixedPointArray = <class 'mpyc.sectypes.SecureFixedPointArray'>
- Base class for secure (secret-shared) arrays of fixed-point numbers.
- SecureFloat = <class 'mpyc.sectypes.SecureFloat'>
- Base class for secure (secret-shared) floating-point numbers.
Basic arithmetic +,-,*,/ and comparisons <,<=,--,>,>=,!= are supported for secure floats,
as well as input()/output() and sorting operations like min()/argmax()/sorted().
Other operations like sum()/prod()/all()/any()/in_prod() are currently not supported for
secure floats.
Implementation is kept simple, representing a secure float as a pair consisting of
a secure fixed-point number for the significand and a secure integer for the exponent.
Note, however, that even basic arithmetic +,-,*,/ with secure floats is very
demanding performance-wise (due to dependence on secure bitwise operations).
- SecureInteger = <class 'mpyc.sectypes.SecureInteger'>
- Base class for secure (secret-shared) integers.
- SecureIntegerArray = <class 'mpyc.sectypes.SecureIntegerArray'>
- Base class for secure (secret-shared) integer arrays.
- SecureNumber = <class 'mpyc.sectypes.SecureNumber'>
- Base class for secure (secret-shared) numbers.
- SecureObject = <class 'mpyc.asyncoro.SecureObject'>
- A secret-shared object.
An MPC protocol operates on secret-shared objects of type SecureObject.
The basic Python operators are overloaded by SecureObject classes.
An expression like a * b will create a new SecureObject, which will
eventually contain the product of a and b. The product is computed
asynchronously, using an instance of a specific cryptographic protocol.
- random = <module 'mpyc.random'>
- This module provides secure versions of several functions for
generating pseudorandom numbers, cf. the random module of Python's
standard library. Each function behaves like its Python counterpart,
except that a secure type is required as additional (first) argument.
Additionally, random_unit_vector() generates a random bit vector
with exactly one bit set to 1, using approximately log_2 n secure
random bits for a bit vector of length n.
Also, random_permutation() and random_derangement() are provided as
convenience functions.
Main concern for the implementations is to minimize the randomness
complexity, that is, to limit the usage of secure random bits as
provided by runtime.random_bits(). Other than this, the code is
relatively simple for now.
NB: runtime._random(sectype, n) cannot be used as an alternative to
_randbelow(sectype, n) as its output is not uniformly random, except
when n is equal to the order of sectype's finite field.
- seclist = <class 'mpyc.seclists.seclist'>
- statistics = <module 'mpyc.statistics'>
- This module provides secure versions of common mathematical statistics functions.
The module is modeled after the statistics module in the Python standard library, and
as such aimed at small scale use ("at the level of graphing and scientific calculators").
Functions mean, median, median_low, median_high, quantiles, and mode are provided
for calculating averages (measures of central location). Functions variance, stdev,
pvariance, pstdev are provided for calculating variability (measures of spread).
Functions covariance, correlation, linear_regression are provided for calculating
statistics regarding relations between two sets of data.
Most of these functions work best with secure fixed-point numbers, but some effort is
done to support the use of secure integers as well. For instance, the mean of a sample
of integers is rounded to the nearest integer, which may still be useful. The variance
of a sample of integers is also rounded to the nearest integer, but this will only be
useful if the sample is properly scaled.
A baseline implementation is provided, favoring simplicity over efficiency. Also, the
current implementations of mode, median, and quantiles favor a small privacy leak over
a strict but less efficient approach.
If these functions are called with plain data, the call is relayed to the corresponding
function in Python's statistics module.
- version = '0.10'
| |