Montgomery modular multiplication

Montgomery form

If a and b are integers in the range [0, N − 1], then their sum is in the range [0, 2N − 2] and their difference is in the range [−N + 1, N − 1], so determining the representative in [0, N − 1] requires at most one subtraction or addition (respectively) of N. However, the product ab is in the range [0, N² − 2N + 1]. Storing the intermediate integer product ab requires twice as many bits as either a or b, and efficiently determining the representative in [0, N − 1] requires division. Mathematically, the integer between 0 and N − 1 that is congruent to ab can be expressed by applying the Euclidean division theorem:

${\displaystyle ab=qN+r,}$

where q is the quotient ${\displaystyle \lfloor ab/N\rfloor }$ and r, the remainder, is in the interval [0, N − 1]. The remainder r is ab mod N. Determining r can be done by computing q, then subtracting qN from ab. For example, again with ${\displaystyle N=17}$, the product 7 ⋅ 15 is determined by computing ${\displaystyle 7\cdot 15=105}$, dividing ${\displaystyle \lfloor 105/17\rfloor =6}$, and subtracting ${\displaystyle 105-6\cdot 17=105-102=3}$.

Because the computation of q requires division, it is undesirably expensive on most computer hardware. Montgomery form is a different way of expressing the elements of the ring in which modular products can be computed without expensive divisions. While divisions are still necessary, they can be done with respect to a different divisor R. This divisor can be chosen to be a power of two, for which division can be replaced by shifting, or a whole number of machine words, for which division can be replaced by omitting words. These divisions are fast, so most of the cost of computing modular products using Montgomery form is the cost of computing ordinary products.

The auxiliary modulus R must be a positive integer such that gcd(R, N) = 1. For computational purposes it is also necessary that division and reduction modulo R are inexpensive, and the modulus is not useful for modular multiplication unless R > N. The Montgomery form of the residue class a with respect to R is aR mod N, that is, it is the representative of the residue class aR. For example, suppose that N = 17 and that R = 100. The Montgomery forms of 3, 5, 7, and 15 are 300 mod 17 = 11, 500 mod 17 = 7, 700 mod 17 = 3, and 1500 mod 17 = 4.

Addition and subtraction in Montgomery form are the same as ordinary modular addition and subtraction because of the distributive law:

${\displaystyle aR+bR=(a+b)R,}$

${\displaystyle aR-bR=(a-b)R.}$

Note that doing the operation in Montgomery form does not lose information compared to doing it in the quotient ring Z/NZ. This is a consequence of the fact that, because gcd(R, N) = 1, multiplication by R is an isomorphism on the additive group Z/NZ. For example, (7 + 15) mod 17 = 5, which in Montgomery form becomes (3 + 4) mod 17 = 7.

Multiplication in Montgomery form, however, is seemingly more complicated. The usual product of aR and bR does not represent the product of a and b because it has an extra factor of R:

${\displaystyle (aRmodN)(bRmodN)modN=(abR)RmodN.}$

Computing products in Montgomery form requires removing the extra factor of R. While division by R is cheap, the intermediate product (aR mod N)(bR mod N) is not divisible by R because the modulo operation has destroyed that property. So for instance, the product of the Montgomery forms of 7 and 15 modulo 17, with R = 100, is the product of 3 and 4, which is 12. Since 12 is not divisible by 100, additional effort is required to remove the extra factor of R.

Removing the extra factor of R can be done by multiplying by an integer R′ such that RR′ ≡ 1 (mod N), that is, by an R′ whose residue class is the modular inverse of R mod N. Then, working modulo N,

${\displaystyle (aRmodN)(bRmodN)R^{\prime }\equiv (aR)(bR)R^{-1}\equiv (ab)R(\mathrm{mod}N).}$

The integer R′ exists because of the assumption that R and N are coprime. It can be constructed using the extended Euclidean algorithm. The extended Euclidean algorithm efficiently determines integers R′ and N′ that satisfy Bézout's identity: 0 < R′ < N, 0 < N′ < R, and:

${\displaystyle R{R}^{\prime }-N{N}^{\prime }=1.}$

This shows that it is possible to do multiplication in Montgomery form. A straightforward algorithm to multiply numbers in Montgomery form is therefore to multiply aR mod N, bR mod N, and R′ as integers and reduce modulo N.

For example, to multiply 7 and 15 modulo 17 in Montgomery form, again with R = 100, compute the product of 3 and 4 to get 12 as above. The extended Euclidean algorithm implies that 8⋅100 − 47⋅17 = 1, so R′ = 8. Multiply 12 by 8 to get 96 and reduce modulo 17 to get 11. This is the Montgomery form of 3, as expected.

The REDC algorithm

While the above algorithm is correct, it is slower than multiplication in the standard representation because of the need to multiply by R′ and divide by N. Montgomery reduction, also known as REDC, is an algorithm that simultaneously computes the product by R′ and reduces modulo N more quickly than the naïve method. Unlike conventional modular reduction, which focuses on making the number smaller than N, Montgomery reduction focuses on making the number more divisible by R. It does this by adding a small multiple of N which is sophisticatedly chosen to cancel the residue modulo R. Dividing the result by R yields a much smaller number. This number is so much smaller that it is nearly the reduction modulo N, and computing the reduction modulo N requires only a final conditional subtraction. Because all computations are done using only reduction and divisions with respect to R, not N, the algorithm runs faster than a straightforward modular reduction by division.

<b id="mw2A">function</b> REDC <b id="mw2Q">is</b> <b id="mw2g">input:</b> Integers <i id="mw2w">R</i> and <i id="mw3A">N</i> with <span class="nowrap" about="#mwt148" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"gcd(''R'', ''N'') = 1"}},"i":0}}]}' id="mw3Q">gcd(<i>R</i>, <i>N</i>) = 1</span>, Integer <i id="mw3g">N</i><span typeof="mw:Entity" id="mw3w">′</span> in <span class="nowrap" about="#mwt149" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"[0, ''R'' &minus; 1]"}},"i":0}}]}' id="mw4A">[0, <i>R</i> <span typeof="mw:Entity">−</span> 1]</span> such that <span class="nowrap" about="#mwt150" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''NN''&prime; ≡ &minus;1 mod ''R''"}},"i":0}}]}' id="mw4Q"><i>NN</i><span typeof="mw:Entity">′</span> ≡ <span typeof="mw:Entity">−</span>1 mod <i>R</i></span>, Integer <i id="mw4g">T</i> in the range <span class="nowrap" about="#mwt151" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"[0, ''RN'' &minus; 1]"}},"i":0}}]}' id="mw4w">[0, <i>RN</i> <span typeof="mw:Entity">−</span> 1]</span>. <b id="mw5A">output:</b> Integer <i id="mw5Q">S</i> in the range <span class="nowrap" about="#mwt152" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"[0, ''N'' &minus; 1]"}},"i":0}}]}' id="mw5g">[0, <i>N</i> <span typeof="mw:Entity">−</span> 1]</span> such that <span class="nowrap" about="#mwt153" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''S'' ≡ ''TR''<sup>&minus;1</sup> mod ''N''"}},"i":0}}]}' id="mw5w"><i>S</i> ≡ <i>TR</i><sup><span typeof="mw:Entity">−</span>1</sup> mod <i>N</i></span> <i id="mw6A">m</i> <span typeof="mw:Entity" id="mw6Q">←</span> ((<i id="mw6g">T</i> mod <i id="mw6w">R</i>)<i id="mw7A">N</i><span typeof="mw:Entity" id="mw7Q">′</span>) mod <i id="mw7g">R</i> <i id="mw7w">t</i> <span typeof="mw:Entity" id="mw8A">←</span> (<i id="mw8Q">T</i> + <i id="mw8g">mN</i>) / <i id="mw8w">R</i> <b id="mw9A">if</b> <i id="mw9Q">t</i> <span typeof="mw:Entity" id="mw9g">≥</span> <i id="mw9w">N</i> <b id="mw-A">then</b> <b id="mw-Q">return</b> <span class="nowrap" about="#mwt154" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''t'' &minus; ''N''"}},"i":0}}]}' id="mw-g"><i>t</i> <span typeof="mw:Entity">−</span> <i>N</i></span> <b id="mw-w">else</b> <b id="mw_A">return</b> <i id="mw_Q">t</i> <b id="mw_g">end if</b> <b id="mw_w">end function</b>

To see that this algorithm is correct, first observe that m is chosen precisely so that T + mN is divisible by R. A number is divisible by R if and only if it is congruent to zero mod R, and we have:

${\displaystyle T+mN\equiv T+(((TmodR)N^{\prime })modR)N\equiv T+T{N}^{\prime }N\equiv T-T\equiv 0(\mathrm{mod}R).}$

Therefore, t is an integer. Second, the output is either t or t − N, both of which are congruent to t mod N, so to prove that the output is congruent to TR⁻¹ mod N, it suffices to prove that t is TR⁻¹ mod N, t satisfies:

${\displaystyle t\equiv (T+mN)R^{-1}\equiv T{R}^{-1}+(m{R}^{-1})N\equiv T{R}^{-1}(\mathrm{mod}N).}$

Therefore, the output has the correct residue class. Third, m is in [0, R − 1], and therefore T + mN is between 0 and (RN − 1) + (R − 1)N < 2RN. Hence t is less than 2N, and because it's an integer, this puts t in the range [0, 2N − 1]. Therefore, reducing t into the desired range requires at most a single subtraction, so the algorithm's output lies in the correct range.

To use REDC to compute the product of 7 and 15 modulo 17, first convert to Montgomery form and multiply as integers to get 12 as above. Then apply REDC with R = 100, N = 17, N′ = 47, and T = 12. The first step sets m to 12 ⋅ 47 mod 100 = 64. The second step sets t to (12 + 64 ⋅ 17) / 100. Notice that 12 + 64 ⋅ 17 is 1100, a multiple of 100 as expected. t is set to 11, which is less than 17, so the final result is 11, which agrees with the computation of the previous section.

As another example, consider the product 7 ⋅ 15 mod 17 but with R = 10. Using the extended Euclidean algorithm, compute −5 ⋅ 10 + 3 ⋅ 17 = 1, so N′ will be −3 mod 10 = 7. The Montgomery forms of 7 and 15 are 70 mod 17 = 2 and 150 mod 17 = 14, respectively. Their product 28 is the input T to REDC, and since 28 < RN = 170, the assumptions of REDC are satisfied. To run REDC, set m to (28 mod 10) ⋅ 7 mod 10 = 196 mod 10 = 6. Then 28 + 6 ⋅ 17 = 130, so t = 13. Because 30 mod 17 = 13, this is the Montgomery form of 3 = 7 ⋅ 15 mod 17.

Interpretation via the Chinese Remainder Theorem

Source:

Given the modulus N and the Montgomery radix R used in a Montgomery reduction, consider the residue ring

${\displaystyle \mathbb{Z}/(NR)\mathbb{Z}\cong \mathbb{Z}/N\mathbb{Z}\times \mathbb{Z}/R\mathbb{Z},}$

an isomorphism that follows from the Chinese Remainder Theorem (CRT).

CRT reconstruction for an intermediate product

For an integer ${\displaystyle T}$ with ${\displaystyle 0\le T<NR}$ (as is typical when ${\displaystyle T}$ arises from multiplying two residues), take its reductions

${\displaystyle T_N=TmodN,T_R=TmodR.}$

The CRT gives the explicit reconstruction formula

${\displaystyle T\equiv T_N(R^{-1}modN)R+T_R(N^{-1}modR)N(\mathrm{mod}NR).}$

Because the right-hand side is already taken modulo ${\displaystyle NR}$, this may also be written as

${\displaystyle T\equiv (T_N{R}^{-1}modN)R+(T_R{N}^{-1}modR)N(\mathrm{mod}NR).}$

Both summands lie in the half‑open interval ${\displaystyle [0,NR)}$:

${\displaystyle 0\le (T_N{R}^{-1}modN)R<NR,0\le (T_R{N}^{-1}modR)N<NR.}$

Hence, as integer equations (not merely congruences) we have

${\displaystyle T=(T_N{R}^{-1}modN)R+(T_R{N}^{-1}modR)N,}$

or,

${\displaystyle T+NR=(T_N{R}^{-1}modN)R+(T_R{N}^{-1}modR)N.}$

Isolating the term containing T mod N

To solve for ${\displaystyle T_N}$, isolate the first summand:

${\displaystyle (T_N{R}^{-1}modN)R=\{\begin{array}{l}T-(T_R{N}^{-1}modR)N,\\ T+NR-(T_R{N}^{-1}modR)N.\end{array}}$

Every quantity above is an integer, and the left‑hand side is a multiple of ${\displaystyle R}$; therefore each right‑hand side is divisible by ${\displaystyle R}$. Dividing by ${\displaystyle R}$ yields

${\displaystyle T_N{R}^{-1}modN=\{\begin{array}{l}{\displaystyle \frac{T-(T_R{N}^{-1}modR)N}{R}},\\ {\displaystyle \frac{T+NR-(T_R{N}^{-1}modR)N}{R}}={\displaystyle \frac{T-(T_R{N}^{-1}modR)N}{R}}+N.\end{array}}$

Resulting relations

Consequently,

${\displaystyle {\displaystyle \frac{T-(T_R{N}^{-1}modR)N}{R}}=\{\begin{array}{l}{T}_N{R}^{-1}modN,\\ T_N{R}^{-1}modN-N.\end{array}}$

This gives two key facts:

• Congruence

${\displaystyle \frac{T-(T_R{N}^{-1}modR)N}{R}\equiv T_N{R}^{-1}(\mathrm{mod}N).}$

• Numeric bound

${\displaystyle -N\le \frac{T-(T_R{N}^{-1}modR)N}{R}<N.}$

Therefore, by reducing

${\displaystyle \frac{T-(T_R{N}^{-1}modR)N}{R}}$

once more modulo N, one obtains the non‑negative residue representing ${\displaystyle T_N{R}^{-1}modN}$.

Arithmetic in Montgomery form

Many operations of interest modulo N can be expressed equally well in Montgomery form. Addition, subtraction, negation, comparison for equality, multiplication by an integer not in Montgomery form, and greatest common divisors with N may all be done with the standard algorithms. The Jacobi symbol can be calculated as ${\displaystyle (\frac{a}{N})=(\frac{aR}{N})/(\frac{R}{N})}$ as long as ${\displaystyle (\frac{R}{N})}$ is stored.

When R > N, most other arithmetic operations can be expressed in terms of REDC. This assumption implies that the product of two representatives mod N is less than RN, the exact hypothesis necessary for REDC to generate correct output. In particular, the product of aR mod N and bR mod N is REDC((aR mod N)(bR mod N)). The combined operation of multiplication and REDC is often called Montgomery multiplication.

Conversion into Montgomery form is done by computing REDC((a mod N)(R² mod N)). Conversion out of Montgomery form is done by computing REDC(aR mod N). The modular inverse of aR mod N is REDC((aR mod N)⁻¹(R³ mod N)). Modular exponentiation can be done using exponentiation by squaring by initializing the initial product to the Montgomery representation of 1, that is, to R mod N, and by replacing the multiply and square steps by Montgomery multiplies.

Performing these operations requires knowing at least N′ and R² mod N. When R is a power of a small positive integer b, N′ can be computed by Hensel's lemma: The inverse of N modulo b is computed by a naïve algorithm (for instance, if b = 2 then the inverse is 1), and Hensel's lemma is used repeatedly to find the inverse modulo higher and higher powers of b, stopping when the inverse modulo R is known; N′ is the negation of this inverse. The constants R mod N and R³ mod N can be generated as REDC(R² mod N) and as REDC((R² mod N)(R² mod N)). The fundamental operation is to compute REDC of a product. When standalone REDC is needed, it can be computed as REDC of a product with 1 mod N. The only place where a direct reduction modulo N is necessary is in the precomputation of R² mod N.

Montgomery arithmetic on multiprecision integers

Most cryptographic applications require numbers that are hundreds or even thousands of bits long. Such numbers are too large to be stored in a single machine word. Typically, the hardware performs multiplication mod some base B, so performing larger multiplications requires combining several small multiplications. The base B is typically 2 for microelectronic applications, 2⁸ for 8-bit firmware, or 2³² or 2⁶⁴ for software applications.

The REDC algorithm requires products modulo R, and typically R > N so that REDC can be used to compute products. However, when R is a power of B, there is a variant of REDC which requires products only of machine word sized integers. Suppose that positive multi-precision integers are stored little endian, that is, x is stored as an array x[0], ..., x[ℓ - 1] such that 0 ≤ x[i] < B for all i and x = ∑ x[i] Bⁱ. The algorithm begins with a multiprecision integer T and reduces it one word at a time. First an appropriate multiple of N is added to make T divisible by B. Then a multiple of N is added to make T divisible by B², and so on. Eventually T is divisible by R, and after division by R the algorithm is in the same place as REDC was after the computation of t.

<b id="mwAdI">function</b> MultiPrecisionREDC <b id="mwAdM">is</b> <b id="mwAdQ">Input:</b> Integer <i id="mwAdU">N</i> with <span class="nowrap" about="#mwt289" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"gcd(''B'', ''N'') = 1"}},"i":0}}]}' id="mwAdY">gcd(<i>B</i>, <i>N</i>) = 1</span>, stored as an array of <i id="mwAdc">p</i> words, Integer <span class="nowrap" about="#mwt290" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''R'' = ''B''<sup>''r''</sup>"}},"i":0}}]}' id="mwAdg"><i>R</i> = <i>B</i><sup><i>r</i></sup></span>, --thus, <i id="mwAdk">r</i> = <i id="mwAdo">log</i><sub id="mwAds"><i id="mwAdw">B</i></sub> <i id="mwAd0">R</i> Integer <i id="mwAd4">N</i><span typeof="mw:Entity" id="mwAd8">′</span> in <span class="nowrap" about="#mwt291" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"[0, ''B'' &minus; 1]"}},"i":0}}]}' id="mwAeA">[0, <i>B</i> <span typeof="mw:Entity">−</span> 1]</span> such that <span class="nowrap" about="#mwt292" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''NN''&prime; ≡ &minus;1 (mod ''B'')"}},"i":0}}]}' id="mwAeE"><i>NN</i><span typeof="mw:Entity">′</span> ≡ <span typeof="mw:Entity">−</span>1 (mod <i>B</i>)</span>, Integer <i id="mwAeI">T</i> in the range <span class="nowrap" about="#mwt293" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"0 &le; ''T'' &lt; ''RN''"}},"i":0}}]}' id="mwAeM">0 <span typeof="mw:Entity">≤</span> <i>T</i> <span typeof="mw:Entity"><</span> <i>RN</i></span>, stored as an array of <span class="nowrap" about="#mwt294" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''r'' + ''p''"}},"i":0}}]}' id="mwAeQ"><i>r</i> + <i>p</i></span> words. <b id="mwAeU">Output:</b> Integer <i id="mwAeY">S</i> in <span class="nowrap" about="#mwt295" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"[0, ''N'' &minus; 1]"}},"i":0}}]}' id="mwAec">[0, <i>N</i> <span typeof="mw:Entity">−</span> 1]</span> such that <span class="nowrap" about="#mwt296" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''TR''<sup>&minus;1</sup> ≡ ''S'' (mod ''N'')"}},"i":0}}]}' id="mwAeg"><i>TR</i><sup><span typeof="mw:Entity">−</span>1</sup> ≡ <i>S</i> (mod <i>N</i>)</span>, stored as an array of <i id="mwAek">p</i> words. Set <span class="nowrap" about="#mwt297" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''T''[''r'' + ''p''] = 0"}},"i":0}}]}' id="mwAeo"><i>T</i>[<i>r</i> + <i>p</i>] = 0</span> <i id="mwAes">(extra carry word)</i> <b id="mwAew">for</b> <span class="nowrap" about="#mwt298" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"0 &le; ''i'' &lt; ''r''"}},"i":0}}]}' id="mwAe0">0 <span typeof="mw:Entity">≤</span> <i>i</i> <span typeof="mw:Entity"><</span> <i>r</i></span> <b id="mwAe4">do</b> <i id="mwAe8">--loop1- Make T divisible by <span class="nowrap" about="#mwt299" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"B<sup>i+1</sup>"}},"i":0}}]}' id="mwAfA">B<sup>i+1</sup></span></i> <i id="mwAfE">c</i> <span typeof="mw:Entity" id="mwAfI">←</span> 0 <i id="mwAfM">m</i> <span typeof="mw:Entity" id="mwAfQ">←</span> <span class="nowrap" about="#mwt300" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''T''[''i''] ⋅ ''N''&prime; mod ''B''"}},"i":0}}]}' id="mwAfU"><i>T</i>[<i>i</i>] ⋅ <i>N</i><span typeof="mw:Entity">′</span> mod <i>B</i></span> <b id="mwAfY">for</b> <span class="nowrap" about="#mwt301" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"0 &le; ''j'' &lt; ''p''"}},"i":0}}]}' id="mwAfc">0 <span typeof="mw:Entity">≤</span> <i>j</i> <span typeof="mw:Entity"><</span> <i>p</i></span> <b id="mwAfg">do</b> <i id="mwAfk">--loop2- Add the <span class="nowrap" about="#mwt302" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"m ⋅ N[j]"}},"i":0}}]}' id="mwAfo">m ⋅ N[j]</span> and the carry from earlier, and find the new carry</i> <i id="mwAfs">x</i> <span typeof="mw:Entity" id="mwAfw">←</span> <span class="nowrap" about="#mwt303" typeof="mw:Transclusion" data-mw="{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''T''[''i'' + ''j''] + ''m'' ⋅ ''N''[''j''] + ''c''"}},"i":0}}]}" id="mwAf0"><i>T</i>[<i>i</i> + <i>j</i>] + <i>m</i> ⋅ <i>N</i>[<i>j</i>] + <i>c</i></span> <i id="mwAf4">T</i>[<i id="mwAf8">i</i> + <i id="mwAgA">j</i>] <span typeof="mw:Entity" id="mwAgE">←</span> <span class="nowrap" about="#mwt304" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''x'' mod ''B''"}},"i":0}}]}' id="mwAgI"><i>x</i> mod <i>B</i></span> <i id="mwAgM">c</i> <span typeof="mw:Entity" id="mwAgQ">←</span> <span class="nowrap" about="#mwt305" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"⌊''x'' / ''B''⌋"}},"i":0}}]}' id="mwAgU">⌊<i>x</i> / <i>B</i>⌋</span> <b id="mwAgY">end for</b> <b id="mwAgc">for</b> <span class="nowrap" about="#mwt306" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''p'' &le; ''j'' &le; ''r'' + ''p'' &minus; ''i''"}},"i":0}}]}' id="mwAgg"><i>p</i> <span typeof="mw:Entity">≤</span> <i>j</i> <span typeof="mw:Entity">≤</span> <i>r</i> + <i>p</i> <span typeof="mw:Entity">−</span> <i>i</i></span> <b id="mwAgk">do</b> <i id="mwAgo">--loop3- Continue carrying</i> <i id="mwAgs">x</i> <span typeof="mw:Entity" id="mwAgw">←</span> <span class="nowrap" about="#mwt307" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''T''[''i'' + ''j''] + ''c''"}},"i":0}}]}' id="mwAg0"><i>T</i>[<i>i</i> + <i>j</i>] + <i>c</i></span> <i id="mwAg4">T</i>[<i id="mwAg8">i</i> + <i id="mwAhA">j</i>] <span typeof="mw:Entity" id="mwAhE">←</span> <span class="nowrap" about="#mwt308" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''x'' mod ''B''"}},"i":0}}]}' id="mwAhI"><i>x</i> mod <i>B</i></span> <i id="mwAhM">c</i> <span typeof="mw:Entity" id="mwAhQ">←</span> <span class="nowrap" about="#mwt309" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"⌊''x'' / ''B''⌋"}},"i":0}}]}' id="mwAhU">⌊<i>x</i> / <i>B</i>⌋</span> <b id="mwAhY">end for</b> <b id="mwAhc">end for</b> <b id="mwAhg">for</b> <span class="nowrap" about="#mwt310" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"0 &le; ''i'' &le; ''p''"}},"i":0}}]}' id="mwAhk">0 <span typeof="mw:Entity">≤</span> <i>i</i> <span typeof="mw:Entity">≤</span> <i>p</i></span> <b id="mwAho">do</b> <i id="mwAhs">S</i>[<i id="mwAhw">i</i>] <span typeof="mw:Entity" id="mwAh0">←</span> <i id="mwAh4">T</i>[<i id="mwAh8">i</i> + <i id="mwAiA">r</i>] <b id="mwAiE">end for</b> <b id="mwAiI">if</b> <span class="nowrap" about="#mwt311" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''S'' &ge; ''N''"}},"i":0}}]}' id="mwAiM"><i>S</i> <span typeof="mw:Entity">≥</span> <i>N</i></span> <b id="mwAiQ">then</b> <b id="mwAiU">return</b> <span class="nowrap" about="#mwt312" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"''S'' &minus; ''N''"}},"i":0}}]}' id="mwAiY"><i>S</i> <span typeof="mw:Entity">−</span> <i>N</i></span> <b id="mwAic">else</b> <b id="mwAig">return</b> <var style="padding-right: 1px;" about="#mwt313" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"var","href":"./Template:Var"},"params":{"1":{"wt":"S"}},"i":0}}]}' id="mwAik">S</var> <b id="mwAio">end if</b> <b id="mwAis">end function</b>

The final comparison and subtraction is done by the standard algorithms.

The above algorithm is correct for essentially the same reasons that REDC is correct. Each time through the i loop, m is chosen so that T[i] + mN[0] is divisible by B. Then mNBⁱ is added to T. Because this quantity is zero mod N, adding it does not affect the value of T mod N. If m_i denotes the value of m computed in the ith iteration of the loop, then the algorithm sets S to T + (∑ m_i Bⁱ)N. Because MultiPrecisionREDC and REDC produce the same output, this sum is the same as the choice of m that the REDC algorithm would make.

The last word of T, T[r + p] (and consequently S[p]), is used only to hold a carry, as the initial reduction result is bound to a result in the range of 0 ≤ S < 2N. It follows that this extra carry word can be avoided completely if it is known in advance that R ≥ 2N. On a typical binary implementation, this is equivalent to saying that this carry word can be avoided if the number of bits of N is smaller than the number of bits of R. Otherwise, the carry will be either zero or one. Depending upon the processor, it may be possible to store this word as a carry flag instead of a full-sized word.

It is possible to combine multiprecision multiplication and REDC into a single algorithm. This combined algorithm is usually called Montgomery multiplication. Several different implementations are described by Koç, Acar, and Kaliski. The algorithm may use as little as p + 2 words of storage (plus a carry bit).

As an example, let B = 10, N = 997, and R = 1000. Suppose that a = 314 and b = 271. The Montgomery representations of a and b are 314000 mod 997 = 942 and 271000 mod 997 = 813. Compute 942 ⋅ 813 = 765846. The initial input T to MultiPrecisionREDC will be [6, 4, 8, 5, 6, 7]. The number N will be represented as [7, 9, 9]. The extended Euclidean algorithm says that −299 ⋅ 10 + 3 ⋅ 997 = 1, so N′ will be 7.

i <span typeof="mw:Entity" id="mwAls">←</span> 0 m <span typeof="mw:Entity" id="mwAlw">←</span> <span class="nowrap" about="#mwt353" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"6 ⋅ 7 mod 10 = 2"}},"i":0}}]}' id="mwAl0">6 ⋅ 7 mod 10 = 2</span> j T c - ------- - 0 0485670 2 <i id="mwAl4">(After first iteration of first loop)</i> 1 0485670 2 2 0485670 2 3 0487670 0 <i id="mwAl8">(After first iteration of second loop)</i> 4 0487670 0 5 0487670 0 6 0487670 0 i <span typeof="mw:Entity" id="mwAmA">←</span> 1 m <span typeof="mw:Entity" id="mwAmE">←</span> <span class="nowrap" about="#mwt354" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"4 ⋅ 7 mod 10 = 8"}},"i":0}}]}' id="mwAmI">4 ⋅ 7 mod 10 = 8</span> j T c - ------- - 0 0087670 6 <i id="mwAmM">(After first iteration of first loop)</i> 1 0067670 8 2 0067670 8 3 0067470 1 <i id="mwAmQ">(After first iteration of second loop)</i> 4 0067480 0 5 0067480 0 i <span typeof="mw:Entity" id="mwAmU">←</span> 2 m <span typeof="mw:Entity" id="mwAmY">←</span> <span class="nowrap" about="#mwt355" typeof="mw:Transclusion" data-mw='{"parts":[{"template":{"target":{"wt":"nowrap","href":"./Template:Nowrap"},"params":{"1":{"wt":"6 ⋅ 7 mod 10 = 2"}},"i":0}}]}' id="mwAmc">6 ⋅ 7 mod 10 = 2</span> j T c - ------- - 0 0007480 2 <i id="mwAmg">(After first iteration of first loop)</i> 1 0007480 2 2 0007480 2 3 0007400 1 <i id="mwAmk">(After first iteration of second loop)</i> 4 0007401 0

Therefore, before the final comparison and subtraction, S = 1047. The final subtraction yields the number 50. Since the Montgomery representation of 314 ⋅ 271 mod 997 = 349 is 349000 mod 997 = 50, this is the expected result.

When working in base 2, determining the correct m at each stage is particularly easy: If the current working bit is even, then m is zero and if it's odd, then m is one. Furthermore, because each step of MultiPrecisionREDC requires knowing only the lowest bit, Montgomery multiplication can be easily combined with a carry-save adder.

Side-channel attacks

Because Montgomery reduction avoids the correction steps required in conventional division when quotient digit estimates are inaccurate, it is mostly free of the conditional branches which are the primary targets of timing and power side-channel attacks; the sequence of instructions executed is independent of the input operand values. The only exception is the final conditional subtraction of the modulus, but it is easily modified (to always subtract something, either the modulus or zero) to make it resistant. It is of course necessary to ensure that the exponentiation algorithm built around the multiplication primitive is also resistant.