xref: /third_party/mbedtls/library/bignum_core.h

97  * \param a     Integer to count leading zero bits.
109  * \param[in] A     The address of the MPI.
110  * \param A_limbs   The number of limbs of \p A.
119  * \param[in,out] A     The address of the MPI.
120  * \param A_limbs       The number of limbs of \p A.
130  * \param min      A machine integer.
131  * \param[in] A    An MPI.
132  * \param A_limbs  The number of limbs of \p A.
145  * \param A        The left-hand MPI. This must point to an array of limbs
147  * \param B        The right-hand MPI. This must point to an array of limbs
149  * \param limbs    The number of limbs in \p A and \p B.
163  * \param[out] X        The address of the destination MPI.
166  * \param[in]  A        The address of the source MPI. This must be initialized.
167  * \param      limbs    The number of limbs of \p A.
168  * \param      assign   The condition deciding whether to perform the
185  * \param[in,out] X         The address of the first MPI.
187  * \param[in,out] Y         The address of the second MPI.
189  * \param         limbs     The number of limbs of \p X and \p Y.
190  * \param         swap      The condition deciding whether to perform
206  * \param[out] X         The address of the MPI.
207  * \param X_limbs        The number of limbs of \p X.
208  * \param[in] input      The input buffer to import from.
209  * \param input_length   The length bytes of \p input.
225  * \param[out] X        The address of the MPI.
228  * \param X_limbs       The number of limbs of \p X.
229  * \param[in] input     The input buffer to import from.
231  * \param input_length  The length in bytes of \p input.
248  * \param[in] A         The address of the MPI.
249  * \param A_limbs       The number of limbs of \p A.
250  * \param[out] output   The output buffer to export to.
251  * \param output_length The length in bytes of \p output.
268  * \param[in] A         The address of the MPI.
269  * \param A_limbs       The number of limbs of \p A.
270  * \param[out] output   The output buffer to export to.
271  * \param output_length The length in bytes of \p output.
290  * \param[in,out] X     The number to shift.
291  * \param limbs         The number of limbs of \p X. This must be at least 1.
292  * \param count         The number of bits to shift by.
305  * \param[in,out] X     The number to shift.
306  * \param limbs         The number of limbs of \p X. This must be at least 1.
307  * \param count         The number of bits to shift by.
322  * \param[out] X    The result of the addition.
323  * \param[in] A     Little-endian presentation of the left operand.
324  * \param[in] B     Little-endian presentation of the right operand.
325  * \param limbs     Number of limbs of \p X, \p A and \p B.
348  * \param[in,out] X  The pointer to the (little-endian) array
350  * \param[in] A      The pointer to the (little-endian) array
354  * \param limbs      Number of limbs of \p X and \p A.
355  * \param cond       Condition bit dictating whether addition should
379  * \param[out] X    The result of the subtraction.
380  * \param[in] A     Little-endian presentation of left operand.
381  * \param[in] B     Little-endian presentation of right operand.
382  * \param limbs     Number of limbs of \p X, \p A and \p B.
400  * \param[in,out] X  The pointer to the (little-endian) array
402  * \param X_limbs    The number of limbs of \p X. This must be
404  * \param[in] A      The pointer to the (little-endian) array
408  * \param A_limbs    The number of limbs of \p A.
409  * \param b          X scalar to multiply with.
423  * \param[out] X     The pointer to the (little-endian) array to receive
426  * \param[in] A      The pointer to the (little-endian) array
428  * \param A_limbs    The number of limbs in \p A.
429  * \param[in] B      The pointer to the (little-endian) array
431  * \param B_limbs    The number of limbs in \p B.
441  * \param[in] N  Little-endian presentation of the modulus. This must have
459  * \param[out]    X         The destination MPI, as a little-endian array of
464  * \param[in]     A         Little-endian presentation of first operand.
466  * \param[in]     B         Little-endian presentation of second operand.
467  * \param[in]     B_limbs   The number of limbs in \p B.
469  * \param[in]     N         Little-endian presentation of the modulus.
474  * \param[in]     AN_limbs  The number of limbs in \p X, \p A and \p N.
475  * \param         mm        The Montgomery constant for \p N: -N^-1 mod 2^biL.
477  * \param[in,out] T         Temporary storage of size at least 2*AN_limbs+1 limbs.
493  * \param[out] X  A pointer to the result of the calculation of
496  * \param[in]  N  Little-endian presentation of the modulus, which must be odd.
511  * \param dest              The destination buffer. This must point to a writable
513  * \param table             The address of the table. This must point to a readable
515  * \param limbs             The number of limbs in each table entry.
516  * \param count             The number of entries in \p table.
517  * \param index             The (secret) table index to look up. This must be in the
530  * \param X        The destination MPI.
531  * \param X_limbs  The number of limbs of \p X.
532  * \param bytes    The number of random bytes to generate.
533  * \param f_rng    The RNG function to use. This must not be \c NULL.
534  * \param p_rng    The RNG parameter to be passed to \p f_rng. This may be
563  * \param X        The destination MPI, with \p limbs limbs.
565  * \param min      The minimum value to return.
566  * \param N        The upper bound of the range, exclusive, with \p limbs limbs.
569  * \param limbs    The number of limbs of \p N and \p X.
571  * \param f_rng    The RNG function to use. This must not be \c NULL.
572  * \param p_rng    The RNG parameter to be passed to \p f_rng.
596  * \param AN_limbs The number of limbs in the input `A` and the modulus `N`
599  * \param E_limbs  The number of limbs in the exponent `E` that will be given
614  * \param[out] X     The destination MPI, as a little endian array of length
616  * \param[in] A      The base MPI, as a little endian array of length \p AN_limbs.
618  * \param[in] N      The modulus, as a little endian array of length \p AN_limbs.
619  * \param AN_limbs   The number of limbs in \p X, \p A, \p N, \p RR.
620  * \param[in] E      The exponent, as a little endian array of length \p E_limbs.
621  * \param E_limbs    The number of limbs in \p E.
622  * \param[in] RR     The precomputed residue of 2^{2*biL} modulo N, as a little
624  * \param[in,out] T  Temporary storage of at least the number of limbs returned
645  * \param[out] X    The result of the subtraction.
646  * \param[in] A     The left operand.
647  * \param b         The unsigned scalar to subtract.
648  * \param limbs     Number of limbs of \p X and \p A.
662  * \param[in] A   The MPI to test.
663  * \param limbs   Number of limbs in \p A.
675  * \param AN_limbs The number of limbs in the input `A` and the modulus `N`
700  * \param[out]    X         The result of the conversion.
702  * \param[in]     A         The MPI to convert into Montgomery form.
704  * \param[in]     N         The address of the modulus, which gives the size of
706  * \param[in]     AN_limbs  The number of limbs in \p X, \p A, \p N and \p rr.
707  * \param         mm        The Montgomery constant for \p N: -N^-1 mod 2^biL.
710  * \param[in]     rr        The residue for `2^{2*n*biL} mod N`.
711  * \param[in,out] T         Temporary storage of size at least
738  * \param[out]    X         The result of the conversion.
740  * \param[in]     A         The MPI to convert from Montgomery form.
742  * \param[in]     N         The address of the modulus, which gives the size of
744  * \param[in]     AN_limbs  The number of limbs in \p X, \p A and \p N.
745  * \param         mm        The Montgomery constant for \p N: -N^-1 mod 2^biL.
748  * \param[in,out] T         Temporary storage of size at least

Indexes created Thu Nov 07 10:32:03 CST 2024