1\documentclass[b5paper]{book} 2\usepackage{hyperref} 3\usepackage{makeidx} 4\usepackage{amssymb} 5\usepackage{color} 6\usepackage{alltt} 7\usepackage{graphicx} 8\usepackage{layout} 9\def\union{\cup} 10\def\intersect{\cap} 11\def\getsrandom{\stackrel{\rm R}{\gets}} 12\def\cross{\times} 13\def\cat{\hspace{0.5em} \| \hspace{0.5em}} 14\def\catn{$\|$} 15\def\divides{\hspace{0.3em} | \hspace{0.3em}} 16\def\nequiv{\not\equiv} 17\def\approx{\raisebox{0.2ex}{\mbox{\small $\sim$}}} 18\def\lcm{{\rm lcm}} 19\def\gcd{{\rm gcd}} 20\def\log{{\rm log}} 21\def\ord{{\rm ord}} 22\def\abs{{\mathit abs}} 23\def\rep{{\mathit rep}} 24\def\mod{{\mathit\ mod\ }} 25\renewcommand{\pmod}[1]{\ ({\rm mod\ }{#1})} 26\newcommand{\floor}[1]{\left\lfloor{#1}\right\rfloor} 27\newcommand{\ceil}[1]{\left\lceil{#1}\right\rceil} 28\def\Or{{\rm\ or\ }} 29\def\And{{\rm\ and\ }} 30\def\iff{\hspace{1em}\Longleftrightarrow\hspace{1em}} 31\def\implies{\Rightarrow} 32\def\undefined{{\rm ``undefined"}} 33\def\Proof{\vspace{1ex}\noindent {\bf Proof:}\hspace{1em}} 34\let\oldphi\phi 35\def\phi{\varphi} 36\def\Pr{{\rm Pr}} 37\newcommand{\str}[1]{{\mathbf{#1}}} 38\def\F{{\mathbb F}} 39\def\N{{\mathbb N}} 40\def\Z{{\mathbb Z}} 41\def\R{{\mathbb R}} 42\def\C{{\mathbb C}} 43\def\Q{{\mathbb Q}} 44\definecolor{DGray}{gray}{0.5} 45\newcommand{\emailaddr}[1]{\mbox{$<${#1}$>$}} 46\def\twiddle{\raisebox{0.3ex}{\mbox{\tiny $\sim$}}} 47\def\gap{\vspace{0.5ex}} 48\makeindex 49\begin{document} 50\frontmatter 51\pagestyle{empty} 52\title{Multi--Precision Math} 53\author{\mbox{ 54%\begin{small} 55\begin{tabular}{c} 56Tom St Denis \\ 57Algonquin College \\ 58\\ 59Mads Rasmussen \\ 60Open Communications Security \\ 61\\ 62Greg Rose \\ 63QUALCOMM Australia \\ 64\end{tabular} 65%\end{small} 66} 67} 68\maketitle 69This text has been placed in the public domain. This text corresponds to the v0.39 release of the 70LibTomMath project. 71 72\begin{alltt} 73Tom St Denis 74111 Banning Rd 75Ottawa, Ontario 76K2L 1C3 77Canada 78 79Phone: 1-613-836-3160 80Email: tomstdenis@gmail.com 81\end{alltt} 82 83This text is formatted to the international B5 paper size of 176mm wide by 250mm tall using the \LaTeX{} 84{\em book} macro package and the Perl {\em booker} package. 85 86\tableofcontents 87\listoffigures 88\chapter*{Prefaces} 89When I tell people about my LibTom projects and that I release them as public domain they are often puzzled. 90They ask why I did it and especially why I continue to work on them for free. The best I can explain it is ``Because I can.'' 91Which seems odd and perhaps too terse for adult conversation. I often qualify it with ``I am able, I am willing.'' which 92perhaps explains it better. I am the first to admit there is not anything that special with what I have done. Perhaps 93others can see that too and then we would have a society to be proud of. My LibTom projects are what I am doing to give 94back to society in the form of tools and knowledge that can help others in their endeavours. 95 96I started writing this book because it was the most logical task to further my goal of open academia. The LibTomMath source 97code itself was written to be easy to follow and learn from. There are times, however, where pure C source code does not 98explain the algorithms properly. Hence this book. The book literally starts with the foundation of the library and works 99itself outwards to the more complicated algorithms. The use of both pseudo--code and verbatim source code provides a duality 100of ``theory'' and ``practice'' that the computer science students of the world shall appreciate. I never deviate too far 101from relatively straightforward algebra and I hope that this book can be a valuable learning asset. 102 103This book and indeed much of the LibTom projects would not exist in their current form if it was not for a plethora 104of kind people donating their time, resources and kind words to help support my work. Writing a text of significant 105length (along with the source code) is a tiresome and lengthy process. Currently the LibTom project is four years old, 106comprises of literally thousands of users and over 100,000 lines of source code, TeX and other material. People like Mads and Greg 107were there at the beginning to encourage me to work well. It is amazing how timely validation from others can boost morale to 108continue the project. Definitely my parents were there for me by providing room and board during the many months of work in 2003. 109 110To my many friends whom I have met through the years I thank you for the good times and the words of encouragement. I hope I 111honour your kind gestures with this project. 112 113Open Source. Open Academia. Open Minds. 114 115\begin{flushright} Tom St Denis \end{flushright} 116 117\newpage 118I found the opportunity to work with Tom appealing for several reasons, not only could I broaden my own horizons, but also 119contribute to educate others facing the problem of having to handle big number mathematical calculations. 120 121This book is Tom's child and he has been caring and fostering the project ever since the beginning with a clear mind of 122how he wanted the project to turn out. I have helped by proofreading the text and we have had several discussions about 123the layout and language used. 124 125I hold a masters degree in cryptography from the University of Southern Denmark and have always been interested in the 126practical aspects of cryptography. 127 128Having worked in the security consultancy business for several years in S\~{a}o Paulo, Brazil, I have been in touch with a 129great deal of work in which multiple precision mathematics was needed. Understanding the possibilities for speeding up 130multiple precision calculations is often very important since we deal with outdated machine architecture where modular 131reductions, for example, become painfully slow. 132 133This text is for people who stop and wonder when first examining algorithms such as RSA for the first time and asks 134themselves, ``You tell me this is only secure for large numbers, fine; but how do you implement these numbers?'' 135 136\begin{flushright} 137Mads Rasmussen 138 139S\~{a}o Paulo - SP 140 141Brazil 142\end{flushright} 143 144\newpage 145It's all because I broke my leg. That just happened to be at about the same time that Tom asked for someone to review the section of the book about 146Karatsuba multiplication. I was laid up, alone and immobile, and thought ``Why not?'' I vaguely knew what Karatsuba multiplication was, but not 147really, so I thought I could help, learn, and stop myself from watching daytime cable TV, all at once. 148 149At the time of writing this, I've still not met Tom or Mads in meatspace. I've been following Tom's progress since his first splash on the 150sci.crypt Usenet news group. I watched him go from a clueless newbie, to the cryptographic equivalent of a reformed smoker, to a real 151contributor to the field, over a period of about two years. I've been impressed with his obvious intelligence, and astounded by his productivity. 152Of course, he's young enough to be my own child, so he doesn't have my problems with staying awake. 153 154When I reviewed that single section of the book, in its very earliest form, I was very pleasantly surprised. So I decided to collaborate more fully, 155and at least review all of it, and perhaps write some bits too. There's still a long way to go with it, and I have watched a number of close 156friends go through the mill of publication, so I think that the way to go is longer than Tom thinks it is. Nevertheless, it's a good effort, 157and I'm pleased to be involved with it. 158 159\begin{flushright} 160Greg Rose, Sydney, Australia, June 2003. 161\end{flushright} 162 163\mainmatter 164\pagestyle{headings} 165\chapter{Introduction} 166\section{Multiple Precision Arithmetic} 167 168\subsection{What is Multiple Precision Arithmetic?} 169When we think of long-hand arithmetic such as addition or multiplication we rarely consider the fact that we instinctively 170raise or lower the precision of the numbers we are dealing with. For example, in decimal we almost immediate can 171reason that $7$ times $6$ is $42$. However, $42$ has two digits of precision as opposed to one digit we started with. 172Further multiplications of say $3$ result in a larger precision result $126$. In these few examples we have multiple 173precisions for the numbers we are working with. Despite the various levels of precision a single subset\footnote{With the occasional optimization.} 174 of algorithms can be designed to accomodate them. 175 176By way of comparison a fixed or single precision operation would lose precision on various operations. For example, in 177the decimal system with fixed precision $6 \cdot 7 = 2$. 178 179Essentially at the heart of computer based multiple precision arithmetic are the same long-hand algorithms taught in 180schools to manually add, subtract, multiply and divide. 181 182\subsection{The Need for Multiple Precision Arithmetic} 183The most prevalent need for multiple precision arithmetic, often referred to as ``bignum'' math, is within the implementation 184of public-key cryptography algorithms. Algorithms such as RSA \cite{RSAREF} and Diffie-Hellman \cite{DHREF} require 185integers of significant magnitude to resist known cryptanalytic attacks. For example, at the time of this writing a 186typical RSA modulus would be at least greater than $10^{309}$. However, modern programming languages such as ISO C \cite{ISOC} and 187Java \cite{JAVA} only provide instrinsic support for integers which are relatively small and single precision. 188 189\begin{figure}[!here] 190\begin{center} 191\begin{tabular}{|r|c|} 192\hline \textbf{Data Type} & \textbf{Range} \\ 193\hline char & $-128 \ldots 127$ \\ 194\hline short & $-32768 \ldots 32767$ \\ 195\hline long & $-2147483648 \ldots 2147483647$ \\ 196\hline long long & $-9223372036854775808 \ldots 9223372036854775807$ \\ 197\hline 198\end{tabular} 199\end{center} 200\caption{Typical Data Types for the C Programming Language} 201\label{fig:ISOC} 202\end{figure} 203 204The largest data type guaranteed to be provided by the ISO C programming 205language\footnote{As per the ISO C standard. However, each compiler vendor is allowed to augment the precision as they 206see fit.} can only represent values up to $10^{19}$ as shown in figure \ref{fig:ISOC}. On its own the C language is 207insufficient to accomodate the magnitude required for the problem at hand. An RSA modulus of magnitude $10^{19}$ could be 208trivially factored\footnote{A Pollard-Rho factoring would take only $2^{16}$ time.} on the average desktop computer, 209rendering any protocol based on the algorithm insecure. Multiple precision algorithms solve this very problem by 210extending the range of representable integers while using single precision data types. 211 212Most advancements in fast multiple precision arithmetic stem from the need for faster and more efficient cryptographic 213primitives. Faster modular reduction and exponentiation algorithms such as Barrett's algorithm, which have appeared in 214various cryptographic journals, can render algorithms such as RSA and Diffie-Hellman more efficient. In fact, several 215major companies such as RSA Security, Certicom and Entrust have built entire product lines on the implementation and 216deployment of efficient algorithms. 217 218However, cryptography is not the only field of study that can benefit from fast multiple precision integer routines. 219Another auxiliary use of multiple precision integers is high precision floating point data types. 220The basic IEEE \cite{IEEE} standard floating point type is made up of an integer mantissa $q$, an exponent $e$ and a sign bit $s$. 221Numbers are given in the form $n = q \cdot b^e \cdot -1^s$ where $b = 2$ is the most common base for IEEE. Since IEEE 222floating point is meant to be implemented in hardware the precision of the mantissa is often fairly small 223(\textit{23, 48 and 64 bits}). The mantissa is merely an integer and a multiple precision integer could be used to create 224a mantissa of much larger precision than hardware alone can efficiently support. This approach could be useful where 225scientific applications must minimize the total output error over long calculations. 226 227Yet another use for large integers is within arithmetic on polynomials of large characteristic (i.e. $GF(p)[x]$ for large $p$). 228In fact the library discussed within this text has already been used to form a polynomial basis library\footnote{See \url{http://poly.libtomcrypt.org} for more details.}. 229 230\subsection{Benefits of Multiple Precision Arithmetic} 231\index{precision} 232The benefit of multiple precision representations over single or fixed precision representations is that 233no precision is lost while representing the result of an operation which requires excess precision. For example, 234the product of two $n$-bit integers requires at least $2n$ bits of precision to be represented faithfully. A multiple 235precision algorithm would augment the precision of the destination to accomodate the result while a single precision system 236would truncate excess bits to maintain a fixed level of precision. 237 238It is possible to implement algorithms which require large integers with fixed precision algorithms. For example, elliptic 239curve cryptography (\textit{ECC}) is often implemented on smartcards by fixing the precision of the integers to the maximum 240size the system will ever need. Such an approach can lead to vastly simpler algorithms which can accomodate the 241integers required even if the host platform cannot natively accomodate them\footnote{For example, the average smartcard 242processor has an 8 bit accumulator.}. However, as efficient as such an approach may be, the resulting source code is not 243normally very flexible. It cannot, at runtime, accomodate inputs of higher magnitude than the designer anticipated. 244 245Multiple precision algorithms have the most overhead of any style of arithmetic. For the the most part the 246overhead can be kept to a minimum with careful planning, but overall, it is not well suited for most memory starved 247platforms. However, multiple precision algorithms do offer the most flexibility in terms of the magnitude of the 248inputs. That is, the same algorithms based on multiple precision integers can accomodate any reasonable size input 249without the designer's explicit forethought. This leads to lower cost of ownership for the code as it only has to 250be written and tested once. 251 252\section{Purpose of This Text} 253The purpose of this text is to instruct the reader regarding how to implement efficient multiple precision algorithms. 254That is to not only explain a limited subset of the core theory behind the algorithms but also the various ``house keeping'' 255elements that are neglected by authors of other texts on the subject. Several well reknowned texts \cite{TAOCPV2,HAC} 256give considerably detailed explanations of the theoretical aspects of algorithms and often very little information 257regarding the practical implementation aspects. 258 259In most cases how an algorithm is explained and how it is actually implemented are two very different concepts. For 260example, the Handbook of Applied Cryptography (\textit{HAC}), algorithm 14.7 on page 594, gives a relatively simple 261algorithm for performing multiple precision integer addition. However, the description lacks any discussion concerning 262the fact that the two integer inputs may be of differing magnitudes. As a result the implementation is not as simple 263as the text would lead people to believe. Similarly the division routine (\textit{algorithm 14.20, pp. 598}) does not 264discuss how to handle sign or handle the dividend's decreasing magnitude in the main loop (\textit{step \#3}). 265 266Both texts also do not discuss several key optimal algorithms required such as ``Comba'' and Karatsuba multipliers 267and fast modular inversion, which we consider practical oversights. These optimal algorithms are vital to achieve 268any form of useful performance in non-trivial applications. 269 270To solve this problem the focus of this text is on the practical aspects of implementing a multiple precision integer 271package. As a case study the ``LibTomMath''\footnote{Available at \url{http://math.libtomcrypt.com}} package is used 272to demonstrate algorithms with real implementations\footnote{In the ISO C programming language.} that have been field 273tested and work very well. The LibTomMath library is freely available on the Internet for all uses and this text 274discusses a very large portion of the inner workings of the library. 275 276The algorithms that are presented will always include at least one ``pseudo-code'' description followed 277by the actual C source code that implements the algorithm. The pseudo-code can be used to implement the same 278algorithm in other programming languages as the reader sees fit. 279 280This text shall also serve as a walkthrough of the creation of multiple precision algorithms from scratch. Showing 281the reader how the algorithms fit together as well as where to start on various taskings. 282 283\section{Discussion and Notation} 284\subsection{Notation} 285A multiple precision integer of $n$-digits shall be denoted as $x = (x_{n-1}, \ldots, x_1, x_0)_{ \beta }$ and represent 286the integer $x \equiv \sum_{i=0}^{n-1} x_i\beta^i$. The elements of the array $x$ are said to be the radix $\beta$ digits 287of the integer. For example, $x = (1,2,3)_{10}$ would represent the integer 288$1\cdot 10^2 + 2\cdot10^1 + 3\cdot10^0 = 123$. 289 290\index{mp\_int} 291The term ``mp\_int'' shall refer to a composite structure which contains the digits of the integer it represents, as well 292as auxilary data required to manipulate the data. These additional members are discussed further in section 293\ref{sec:MPINT}. For the purposes of this text a ``multiple precision integer'' and an ``mp\_int'' are assumed to be 294synonymous. When an algorithm is specified to accept an mp\_int variable it is assumed the various auxliary data members 295are present as well. An expression of the type \textit{variablename.item} implies that it should evaluate to the 296member named ``item'' of the variable. For example, a string of characters may have a member ``length'' which would 297evaluate to the number of characters in the string. If the string $a$ equals ``hello'' then it follows that 298$a.length = 5$. 299 300For certain discussions more generic algorithms are presented to help the reader understand the final algorithm used 301to solve a given problem. When an algorithm is described as accepting an integer input it is assumed the input is 302a plain integer with no additional multiple-precision members. That is, algorithms that use integers as opposed to 303mp\_ints as inputs do not concern themselves with the housekeeping operations required such as memory management. These 304algorithms will be used to establish the relevant theory which will subsequently be used to describe a multiple 305precision algorithm to solve the same problem. 306 307\subsection{Precision Notation} 308The variable $\beta$ represents the radix of a single digit of a multiple precision integer and 309must be of the form $q^p$ for $q, p \in \Z^+$. A single precision variable must be able to represent integers in 310the range $0 \le x < q \beta$ while a double precision variable must be able to represent integers in the range 311$0 \le x < q \beta^2$. The extra radix-$q$ factor allows additions and subtractions to proceed without truncation of the 312carry. Since all modern computers are binary, it is assumed that $q$ is two. 313 314\index{mp\_digit} \index{mp\_word} 315Within the source code that will be presented for each algorithm, the data type \textbf{mp\_digit} will represent 316a single precision integer type, while, the data type \textbf{mp\_word} will represent a double precision integer type. In 317several algorithms (notably the Comba routines) temporary results will be stored in arrays of double precision mp\_words. 318For the purposes of this text $x_j$ will refer to the $j$'th digit of a single precision array and $\hat x_j$ will refer to 319the $j$'th digit of a double precision array. Whenever an expression is to be assigned to a double precision 320variable it is assumed that all single precision variables are promoted to double precision during the evaluation. 321Expressions that are assigned to a single precision variable are truncated to fit within the precision of a single 322precision data type. 323 324For example, if $\beta = 10^2$ a single precision data type may represent a value in the 325range $0 \le x < 10^3$, while a double precision data type may represent a value in the range $0 \le x < 10^5$. Let 326$a = 23$ and $b = 49$ represent two single precision variables. The single precision product shall be written 327as $c \leftarrow a \cdot b$ while the double precision product shall be written as $\hat c \leftarrow a \cdot b$. 328In this particular case, $\hat c = 1127$ and $c = 127$. The most significant digit of the product would not fit 329in a single precision data type and as a result $c \ne \hat c$. 330 331\subsection{Algorithm Inputs and Outputs} 332Within the algorithm descriptions all variables are assumed to be scalars of either single or double precision 333as indicated. The only exception to this rule is when variables have been indicated to be of type mp\_int. This 334distinction is important as scalars are often used as array indicies and various other counters. 335 336\subsection{Mathematical Expressions} 337The $\lfloor \mbox{ } \rfloor$ brackets imply an expression truncated to an integer not greater than the expression 338itself. For example, $\lfloor 5.7 \rfloor = 5$. Similarly the $\lceil \mbox{ } \rceil$ brackets imply an expression 339rounded to an integer not less than the expression itself. For example, $\lceil 5.1 \rceil = 6$. Typically when 340the $/$ division symbol is used the intention is to perform an integer division with truncation. For example, 341$5/2 = 2$ which will often be written as $\lfloor 5/2 \rfloor = 2$ for clarity. When an expression is written as a 342fraction a real value division is implied, for example ${5 \over 2} = 2.5$. 343 344The norm of a multiple precision integer, for example $\vert \vert x \vert \vert$, will be used to represent the number of digits in the representation 345of the integer. For example, $\vert \vert 123 \vert \vert = 3$ and $\vert \vert 79452 \vert \vert = 5$. 346 347\subsection{Work Effort} 348\index{big-Oh} 349To measure the efficiency of the specified algorithms, a modified big-Oh notation is used. In this system all 350single precision operations are considered to have the same cost\footnote{Except where explicitly noted.}. 351That is a single precision addition, multiplication and division are assumed to take the same time to 352complete. While this is generally not true in practice, it will simplify the discussions considerably. 353 354Some algorithms have slight advantages over others which is why some constants will not be removed in 355the notation. For example, a normal baseline multiplication (section \ref{sec:basemult}) requires $O(n^2)$ work while a 356baseline squaring (section \ref{sec:basesquare}) requires $O({{n^2 + n}\over 2})$ work. In standard big-Oh notation these 357would both be said to be equivalent to $O(n^2)$. However, 358in the context of the this text this is not the case as the magnitude of the inputs will typically be rather small. As a 359result small constant factors in the work effort will make an observable difference in algorithm efficiency. 360 361All of the algorithms presented in this text have a polynomial time work level. That is, of the form 362$O(n^k)$ for $n, k \in \Z^{+}$. This will help make useful comparisons in terms of the speed of the algorithms and how 363various optimizations will help pay off in the long run. 364 365\section{Exercises} 366Within the more advanced chapters a section will be set aside to give the reader some challenging exercises related to 367the discussion at hand. These exercises are not designed to be prize winning problems, but instead to be thought 368provoking. Wherever possible the problems are forward minded, stating problems that will be answered in subsequent 369chapters. The reader is encouraged to finish the exercises as they appear to get a better understanding of the 370subject material. 371 372That being said, the problems are designed to affirm knowledge of a particular subject matter. Students in particular 373are encouraged to verify they can answer the problems correctly before moving on. 374 375Similar to the exercises of \cite[pp. ix]{TAOCPV2} these exercises are given a scoring system based on the difficulty of 376the problem. However, unlike \cite{TAOCPV2} the problems do not get nearly as hard. The scoring of these 377exercises ranges from one (the easiest) to five (the hardest). The following table sumarizes the 378scoring system used. 379 380\begin{figure}[here] 381\begin{center} 382\begin{small} 383\begin{tabular}{|c|l|} 384\hline $\left [ 1 \right ]$ & An easy problem that should only take the reader a manner of \\ 385 & minutes to solve. Usually does not involve much computer time \\ 386 & to solve. \\ 387\hline $\left [ 2 \right ]$ & An easy problem that involves a marginal amount of computer \\ 388 & time usage. Usually requires a program to be written to \\ 389 & solve the problem. \\ 390\hline $\left [ 3 \right ]$ & A moderately hard problem that requires a non-trivial amount \\ 391 & of work. Usually involves trivial research and development of \\ 392 & new theory from the perspective of a student. \\ 393\hline $\left [ 4 \right ]$ & A moderately hard problem that involves a non-trivial amount \\ 394 & of work and research, the solution to which will demonstrate \\ 395 & a higher mastery of the subject matter. \\ 396\hline $\left [ 5 \right ]$ & A hard problem that involves concepts that are difficult for a \\ 397 & novice to solve. Solutions to these problems will demonstrate a \\ 398 & complete mastery of the given subject. \\ 399\hline 400\end{tabular} 401\end{small} 402\end{center} 403\caption{Exercise Scoring System} 404\end{figure} 405 406Problems at the first level are meant to be simple questions that the reader can answer quickly without programming a solution or 407devising new theory. These problems are quick tests to see if the material is understood. Problems at the second level 408are also designed to be easy but will require a program or algorithm to be implemented to arrive at the answer. These 409two levels are essentially entry level questions. 410 411Problems at the third level are meant to be a bit more difficult than the first two levels. The answer is often 412fairly obvious but arriving at an exacting solution requires some thought and skill. These problems will almost always 413involve devising a new algorithm or implementing a variation of another algorithm previously presented. Readers who can 414answer these questions will feel comfortable with the concepts behind the topic at hand. 415 416Problems at the fourth level are meant to be similar to those of the level three questions except they will require 417additional research to be completed. The reader will most likely not know the answer right away, nor will the text provide 418the exact details of the answer until a subsequent chapter. 419 420Problems at the fifth level are meant to be the hardest 421problems relative to all the other problems in the chapter. People who can correctly answer fifth level problems have a 422mastery of the subject matter at hand. 423 424Often problems will be tied together. The purpose of this is to start a chain of thought that will be discussed in future chapters. The reader 425is encouraged to answer the follow-up problems and try to draw the relevance of problems. 426 427\section{Introduction to LibTomMath} 428 429\subsection{What is LibTomMath?} 430LibTomMath is a free and open source multiple precision integer library written entirely in portable ISO C. By portable it 431is meant that the library does not contain any code that is computer platform dependent or otherwise problematic to use on 432any given platform. 433 434The library has been successfully tested under numerous operating systems including Unix\footnote{All of these 435trademarks belong to their respective rightful owners.}, MacOS, Windows, Linux, PalmOS and on standalone hardware such 436as the Gameboy Advance. The library is designed to contain enough functionality to be able to develop applications such 437as public key cryptosystems and still maintain a relatively small footprint. 438 439\subsection{Goals of LibTomMath} 440 441Libraries which obtain the most efficiency are rarely written in a high level programming language such as C. However, 442even though this library is written entirely in ISO C, considerable care has been taken to optimize the algorithm implementations within the 443library. Specifically the code has been written to work well with the GNU C Compiler (\textit{GCC}) on both x86 and ARM 444processors. Wherever possible, highly efficient algorithms, such as Karatsuba multiplication, sliding window 445exponentiation and Montgomery reduction have been provided to make the library more efficient. 446 447Even with the nearly optimal and specialized algorithms that have been included the Application Programing Interface 448(\textit{API}) has been kept as simple as possible. Often generic place holder routines will make use of specialized 449algorithms automatically without the developer's specific attention. One such example is the generic multiplication 450algorithm \textbf{mp\_mul()} which will automatically use Toom--Cook, Karatsuba, Comba or baseline multiplication 451based on the magnitude of the inputs and the configuration of the library. 452 453Making LibTomMath as efficient as possible is not the only goal of the LibTomMath project. Ideally the library should 454be source compatible with another popular library which makes it more attractive for developers to use. In this case the 455MPI library was used as a API template for all the basic functions. MPI was chosen because it is another library that fits 456in the same niche as LibTomMath. Even though LibTomMath uses MPI as the template for the function names and argument 457passing conventions, it has been written from scratch by Tom St Denis. 458 459The project is also meant to act as a learning tool for students, the logic being that no easy-to-follow ``bignum'' 460library exists which can be used to teach computer science students how to perform fast and reliable multiple precision 461integer arithmetic. To this end the source code has been given quite a few comments and algorithm discussion points. 462 463\section{Choice of LibTomMath} 464LibTomMath was chosen as the case study of this text not only because the author of both projects is one and the same but 465for more worthy reasons. Other libraries such as GMP \cite{GMP}, MPI \cite{MPI}, LIP \cite{LIP} and OpenSSL 466\cite{OPENSSL} have multiple precision integer arithmetic routines but would not be ideal for this text for 467reasons that will be explained in the following sub-sections. 468 469\subsection{Code Base} 470The LibTomMath code base is all portable ISO C source code. This means that there are no platform dependent conditional 471segments of code littered throughout the source. This clean and uncluttered approach to the library means that a 472developer can more readily discern the true intent of a given section of source code without trying to keep track of 473what conditional code will be used. 474 475The code base of LibTomMath is well organized. Each function is in its own separate source code file 476which allows the reader to find a given function very quickly. On average there are $76$ lines of code per source 477file which makes the source very easily to follow. By comparison MPI and LIP are single file projects making code tracing 478very hard. GMP has many conditional code segments which also hinder tracing. 479 480When compiled with GCC for the x86 processor and optimized for speed the entire library is approximately $100$KiB\footnote{The notation ``KiB'' means $2^{10}$ octets, similarly ``MiB'' means $2^{20}$ octets.} 481 which is fairly small compared to GMP (over $250$KiB). LibTomMath is slightly larger than MPI (which compiles to about 482$50$KiB) but LibTomMath is also much faster and more complete than MPI. 483 484\subsection{API Simplicity} 485LibTomMath is designed after the MPI library and shares the API design. Quite often programs that use MPI will build 486with LibTomMath without change. The function names correlate directly to the action they perform. Almost all of the 487functions share the same parameter passing convention. The learning curve is fairly shallow with the API provided 488which is an extremely valuable benefit for the student and developer alike. 489 490The LIP library is an example of a library with an API that is awkward to work with. LIP uses function names that are often ``compressed'' to 491illegible short hand. LibTomMath does not share this characteristic. 492 493The GMP library also does not return error codes. Instead it uses a POSIX.1 \cite{POSIX1} signal system where errors 494are signaled to the host application. This happens to be the fastest approach but definitely not the most versatile. In 495effect a math error (i.e. invalid input, heap error, etc) can cause a program to stop functioning which is definitely 496undersireable in many situations. 497 498\subsection{Optimizations} 499While LibTomMath is certainly not the fastest library (GMP often beats LibTomMath by a factor of two) it does 500feature a set of optimal algorithms for tasks such as modular reduction, exponentiation, multiplication and squaring. GMP 501and LIP also feature such optimizations while MPI only uses baseline algorithms with no optimizations. GMP lacks a few 502of the additional modular reduction optimizations that LibTomMath features\footnote{At the time of this writing GMP 503only had Barrett and Montgomery modular reduction algorithms.}. 504 505LibTomMath is almost always an order of magnitude faster than the MPI library at computationally expensive tasks such as modular 506exponentiation. In the grand scheme of ``bignum'' libraries LibTomMath is faster than the average library and usually 507slower than the best libraries such as GMP and OpenSSL by only a small factor. 508 509\subsection{Portability and Stability} 510LibTomMath will build ``out of the box'' on any platform equipped with a modern version of the GNU C Compiler 511(\textit{GCC}). This means that without changes the library will build without configuration or setting up any 512variables. LIP and MPI will build ``out of the box'' as well but have numerous known bugs. Most notably the author of 513MPI has recently stopped working on his library and LIP has long since been discontinued. 514 515GMP requires a configuration script to run and will not build out of the box. GMP and LibTomMath are still in active 516development and are very stable across a variety of platforms. 517 518\subsection{Choice} 519LibTomMath is a relatively compact, well documented, highly optimized and portable library which seems only natural for 520the case study of this text. Various source files from the LibTomMath project will be included within the text. However, 521the reader is encouraged to download their own copy of the library to actually be able to work with the library. 522 523\chapter{Getting Started} 524\section{Library Basics} 525The trick to writing any useful library of source code is to build a solid foundation and work outwards from it. First, 526a problem along with allowable solution parameters should be identified and analyzed. In this particular case the 527inability to accomodate multiple precision integers is the problem. Futhermore, the solution must be written 528as portable source code that is reasonably efficient across several different computer platforms. 529 530After a foundation is formed the remainder of the library can be designed and implemented in a hierarchical fashion. 531That is, to implement the lowest level dependencies first and work towards the most abstract functions last. For example, 532before implementing a modular exponentiation algorithm one would implement a modular reduction algorithm. 533By building outwards from a base foundation instead of using a parallel design methodology the resulting project is 534highly modular. Being highly modular is a desirable property of any project as it often means the resulting product 535has a small footprint and updates are easy to perform. 536 537Usually when I start a project I will begin with the header files. I define the data types I think I will need and 538prototype the initial functions that are not dependent on other functions (within the library). After I 539implement these base functions I prototype more dependent functions and implement them. The process repeats until 540I implement all of the functions I require. For example, in the case of LibTomMath I implemented functions such as 541mp\_init() well before I implemented mp\_mul() and even further before I implemented mp\_exptmod(). As an example as to 542why this design works note that the Karatsuba and Toom-Cook multipliers were written \textit{after} the 543dependent function mp\_exptmod() was written. Adding the new multiplication algorithms did not require changes to the 544mp\_exptmod() function itself and lowered the total cost of ownership (\textit{so to speak}) and of development 545for new algorithms. This methodology allows new algorithms to be tested in a complete framework with relative ease. 546 547\begin{center} 548\begin{figure}[here] 549\includegraphics{pics/design_process.ps} 550\caption{Design Flow of the First Few Original LibTomMath Functions.} 551\label{pic:design_process} 552\end{figure} 553\end{center} 554 555Only after the majority of the functions were in place did I pursue a less hierarchical approach to auditing and optimizing 556the source code. For example, one day I may audit the multipliers and the next day the polynomial basis functions. 557 558It only makes sense to begin the text with the preliminary data types and support algorithms required as well. 559This chapter discusses the core algorithms of the library which are the dependents for every other algorithm. 560 561\section{What is a Multiple Precision Integer?} 562Recall that most programming languages, in particular ISO C \cite{ISOC}, only have fixed precision data types that on their own cannot 563be used to represent values larger than their precision will allow. The purpose of multiple precision algorithms is 564to use fixed precision data types to create and manipulate multiple precision integers which may represent values 565that are very large. 566 567As a well known analogy, school children are taught how to form numbers larger than nine by prepending more radix ten digits. In the decimal system 568the largest single digit value is $9$. However, by concatenating digits together larger numbers may be represented. Newly prepended digits 569(\textit{to the left}) are said to be in a different power of ten column. That is, the number $123$ can be described as having a $1$ in the hundreds 570column, $2$ in the tens column and $3$ in the ones column. Or more formally $123 = 1 \cdot 10^2 + 2 \cdot 10^1 + 3 \cdot 10^0$. Computer based 571multiple precision arithmetic is essentially the same concept. Larger integers are represented by adjoining fixed 572precision computer words with the exception that a different radix is used. 573 574What most people probably do not think about explicitly are the various other attributes that describe a multiple precision 575integer. For example, the integer $154_{10}$ has two immediately obvious properties. First, the integer is positive, 576that is the sign of this particular integer is positive as opposed to negative. Second, the integer has three digits in 577its representation. There is an additional property that the integer posesses that does not concern pencil-and-paper 578arithmetic. The third property is how many digits placeholders are available to hold the integer. 579 580The human analogy of this third property is ensuring there is enough space on the paper to write the integer. For example, 581if one starts writing a large number too far to the right on a piece of paper they will have to erase it and move left. 582Similarly, computer algorithms must maintain strict control over memory usage to ensure that the digits of an integer 583will not exceed the allowed boundaries. These three properties make up what is known as a multiple precision 584integer or mp\_int for short. 585 586\subsection{The mp\_int Structure} 587\label{sec:MPINT} 588The mp\_int structure is the ISO C based manifestation of what represents a multiple precision integer. The ISO C standard does not provide for 589any such data type but it does provide for making composite data types known as structures. The following is the structure definition 590used within LibTomMath. 591 592\index{mp\_int} 593\begin{figure}[here] 594\begin{center} 595\begin{small} 596%\begin{verbatim} 597\begin{tabular}{|l|} 598\hline 599typedef struct \{ \\ 600\hspace{3mm}int used, alloc, sign;\\ 601\hspace{3mm}mp\_digit *dp;\\ 602\} \textbf{mp\_int}; \\ 603\hline 604\end{tabular} 605%\end{verbatim} 606\end{small} 607\caption{The mp\_int Structure} 608\label{fig:mpint} 609\end{center} 610\end{figure} 611 612The mp\_int structure (fig. \ref{fig:mpint}) can be broken down as follows. 613 614\begin{enumerate} 615\item The \textbf{used} parameter denotes how many digits of the array \textbf{dp} contain the digits used to represent 616a given integer. The \textbf{used} count must be positive (or zero) and may not exceed the \textbf{alloc} count. 617 618\item The \textbf{alloc} parameter denotes how 619many digits are available in the array to use by functions before it has to increase in size. When the \textbf{used} count 620of a result would exceed the \textbf{alloc} count all of the algorithms will automatically increase the size of the 621array to accommodate the precision of the result. 622 623\item The pointer \textbf{dp} points to a dynamically allocated array of digits that represent the given multiple 624precision integer. It is padded with $(\textbf{alloc} - \textbf{used})$ zero digits. The array is maintained in a least 625significant digit order. As a pencil and paper analogy the array is organized such that the right most digits are stored 626first starting at the location indexed by zero\footnote{In C all arrays begin at zero.} in the array. For example, 627if \textbf{dp} contains $\lbrace a, b, c, \ldots \rbrace$ where \textbf{dp}$_0 = a$, \textbf{dp}$_1 = b$, \textbf{dp}$_2 = c$, $\ldots$ then 628it would represent the integer $a + b\beta + c\beta^2 + \ldots$ 629 630\index{MP\_ZPOS} \index{MP\_NEG} 631\item The \textbf{sign} parameter denotes the sign as either zero/positive (\textbf{MP\_ZPOS}) or negative (\textbf{MP\_NEG}). 632\end{enumerate} 633 634\subsubsection{Valid mp\_int Structures} 635Several rules are placed on the state of an mp\_int structure and are assumed to be followed for reasons of efficiency. 636The only exceptions are when the structure is passed to initialization functions such as mp\_init() and mp\_init\_copy(). 637 638\begin{enumerate} 639\item The value of \textbf{alloc} may not be less than one. That is \textbf{dp} always points to a previously allocated 640array of digits. 641\item The value of \textbf{used} may not exceed \textbf{alloc} and must be greater than or equal to zero. 642\item The value of \textbf{used} implies the digit at index $(used - 1)$ of the \textbf{dp} array is non-zero. That is, 643leading zero digits in the most significant positions must be trimmed. 644 \begin{enumerate} 645 \item Digits in the \textbf{dp} array at and above the \textbf{used} location must be zero. 646 \end{enumerate} 647\item The value of \textbf{sign} must be \textbf{MP\_ZPOS} if \textbf{used} is zero; 648this represents the mp\_int value of zero. 649\end{enumerate} 650 651\section{Argument Passing} 652A convention of argument passing must be adopted early on in the development of any library. Making the function 653prototypes consistent will help eliminate many headaches in the future as the library grows to significant complexity. 654In LibTomMath the multiple precision integer functions accept parameters from left to right as pointers to mp\_int 655structures. That means that the source (input) operands are placed on the left and the destination (output) on the right. 656Consider the following examples. 657 658\begin{verbatim} 659 mp_mul(&a, &b, &c); /* c = a * b */ 660 mp_add(&a, &b, &a); /* a = a + b */ 661 mp_sqr(&a, &b); /* b = a * a */ 662\end{verbatim} 663 664The left to right order is a fairly natural way to implement the functions since it lets the developer read aloud the 665functions and make sense of them. For example, the first function would read ``multiply a and b and store in c''. 666 667Certain libraries (\textit{LIP by Lenstra for instance}) accept parameters the other way around, to mimic the order 668of assignment expressions. That is, the destination (output) is on the left and arguments (inputs) are on the right. In 669truth, it is entirely a matter of preference. In the case of LibTomMath the convention from the MPI library has been 670adopted. 671 672Another very useful design consideration, provided for in LibTomMath, is whether to allow argument sources to also be a 673destination. For example, the second example (\textit{mp\_add}) adds $a$ to $b$ and stores in $a$. This is an important 674feature to implement since it allows the calling functions to cut down on the number of variables it must maintain. 675However, to implement this feature specific care has to be given to ensure the destination is not modified before the 676source is fully read. 677 678\section{Return Values} 679A well implemented application, no matter what its purpose, should trap as many runtime errors as possible and return them 680to the caller. By catching runtime errors a library can be guaranteed to prevent undefined behaviour. However, the end 681developer can still manage to cause a library to crash. For example, by passing an invalid pointer an application may 682fault by dereferencing memory not owned by the application. 683 684In the case of LibTomMath the only errors that are checked for are related to inappropriate inputs (division by zero for 685instance) and memory allocation errors. It will not check that the mp\_int passed to any function is valid nor 686will it check pointers for validity. Any function that can cause a runtime error will return an error code as an 687\textbf{int} data type with one of the following values (fig \ref{fig:errcodes}). 688 689\index{MP\_OKAY} \index{MP\_VAL} \index{MP\_MEM} 690\begin{figure}[here] 691\begin{center} 692\begin{tabular}{|l|l|} 693\hline \textbf{Value} & \textbf{Meaning} \\ 694\hline \textbf{MP\_OKAY} & The function was successful \\ 695\hline \textbf{MP\_VAL} & One of the input value(s) was invalid \\ 696\hline \textbf{MP\_MEM} & The function ran out of heap memory \\ 697\hline 698\end{tabular} 699\end{center} 700\caption{LibTomMath Error Codes} 701\label{fig:errcodes} 702\end{figure} 703 704When an error is detected within a function it should free any memory it allocated, often during the initialization of 705temporary mp\_ints, and return as soon as possible. The goal is to leave the system in the same state it was when the 706function was called. Error checking with this style of API is fairly simple. 707 708\begin{verbatim} 709 int err; 710 if ((err = mp_add(&a, &b, &c)) != MP_OKAY) { 711 printf("Error: %s\n", mp_error_to_string(err)); 712 exit(EXIT_FAILURE); 713 } 714\end{verbatim} 715 716The GMP \cite{GMP} library uses C style \textit{signals} to flag errors which is of questionable use. Not all errors are fatal 717and it was not deemed ideal by the author of LibTomMath to force developers to have signal handlers for such cases. 718 719\section{Initialization and Clearing} 720The logical starting point when actually writing multiple precision integer functions is the initialization and 721clearing of the mp\_int structures. These two algorithms will be used by the majority of the higher level algorithms. 722 723Given the basic mp\_int structure an initialization routine must first allocate memory to hold the digits of 724the integer. Often it is optimal to allocate a sufficiently large pre-set number of digits even though 725the initial integer will represent zero. If only a single digit were allocated quite a few subsequent re-allocations 726would occur when operations are performed on the integers. There is a tradeoff between how many default digits to allocate 727and how many re-allocations are tolerable. Obviously allocating an excessive amount of digits initially will waste 728memory and become unmanageable. 729 730If the memory for the digits has been successfully allocated then the rest of the members of the structure must 731be initialized. Since the initial state of an mp\_int is to represent the zero integer, the allocated digits must be set 732to zero. The \textbf{used} count set to zero and \textbf{sign} set to \textbf{MP\_ZPOS}. 733 734\subsection{Initializing an mp\_int} 735An mp\_int is said to be initialized if it is set to a valid, preferably default, state such that all of the members of the 736structure are set to valid values. The mp\_init algorithm will perform such an action. 737 738\index{mp\_init} 739\begin{figure}[here] 740\begin{center} 741\begin{tabular}{l} 742\hline Algorithm \textbf{mp\_init}. \\ 743\textbf{Input}. An mp\_int $a$ \\ 744\textbf{Output}. Allocate memory and initialize $a$ to a known valid mp\_int state. \\ 745\hline \\ 7461. Allocate memory for \textbf{MP\_PREC} digits. \\ 7472. If the allocation failed return(\textit{MP\_MEM}) \\ 7483. for $n$ from $0$ to $MP\_PREC - 1$ do \\ 749\hspace{3mm}3.1 $a_n \leftarrow 0$\\ 7504. $a.sign \leftarrow MP\_ZPOS$\\ 7515. $a.used \leftarrow 0$\\ 7526. $a.alloc \leftarrow MP\_PREC$\\ 7537. Return(\textit{MP\_OKAY})\\ 754\hline 755\end{tabular} 756\end{center} 757\caption{Algorithm mp\_init} 758\end{figure} 759 760\textbf{Algorithm mp\_init.} 761The purpose of this function is to initialize an mp\_int structure so that the rest of the library can properly 762manipulte it. It is assumed that the input may not have had any of its members previously initialized which is certainly 763a valid assumption if the input resides on the stack. 764 765Before any of the members such as \textbf{sign}, \textbf{used} or \textbf{alloc} are initialized the memory for 766the digits is allocated. If this fails the function returns before setting any of the other members. The \textbf{MP\_PREC} 767name represents a constant\footnote{Defined in the ``tommath.h'' header file within LibTomMath.} 768used to dictate the minimum precision of newly initialized mp\_int integers. Ideally, it is at least equal to the smallest 769precision number you'll be working with. 770 771Allocating a block of digits at first instead of a single digit has the benefit of lowering the number of usually slow 772heap operations later functions will have to perform in the future. If \textbf{MP\_PREC} is set correctly the slack 773memory and the number of heap operations will be trivial. 774 775Once the allocation has been made the digits have to be set to zero as well as the \textbf{used}, \textbf{sign} and 776\textbf{alloc} members initialized. This ensures that the mp\_int will always represent the default state of zero regardless 777of the original condition of the input. 778 779\textbf{Remark.} 780This function introduces the idiosyncrasy that all iterative loops, commonly initiated with the ``for'' keyword, iterate incrementally 781when the ``to'' keyword is placed between two expressions. For example, ``for $a$ from $b$ to $c$ do'' means that 782a subsequent expression (or body of expressions) are to be evaluated upto $c - b$ times so long as $b \le c$. In each 783iteration the variable $a$ is substituted for a new integer that lies inclusively between $b$ and $c$. If $b > c$ occured 784the loop would not iterate. By contrast if the ``downto'' keyword were used in place of ``to'' the loop would iterate 785decrementally. 786 787\vspace{+3mm}\begin{small} 788\hspace{-5.1mm}{\bf File}: bn\_mp\_init.c 789\vspace{-3mm} 790\begin{alltt} 791\end{alltt} 792\end{small} 793 794One immediate observation of this initializtion function is that it does not return a pointer to a mp\_int structure. It 795is assumed that the caller has already allocated memory for the mp\_int structure, typically on the application stack. The 796call to mp\_init() is used only to initialize the members of the structure to a known default state. 797 798Here we see (line 24) the memory allocation is performed first. This allows us to exit cleanly and quickly 799if there is an error. If the allocation fails the routine will return \textbf{MP\_MEM} to the caller to indicate there 800was a memory error. The function XMALLOC is what actually allocates the memory. Technically XMALLOC is not a function 801but a macro defined in ``tommath.h``. By default, XMALLOC will evaluate to malloc() which is the C library's built--in 802memory allocation routine. 803 804In order to assure the mp\_int is in a known state the digits must be set to zero. On most platforms this could have been 805accomplished by using calloc() instead of malloc(). However, to correctly initialize a integer type to a given value in a 806portable fashion you have to actually assign the value. The for loop (line 30) performs this required 807operation. 808 809After the memory has been successfully initialized the remainder of the members are initialized 810(lines 34 through 35) to their respective default states. At this point the algorithm has succeeded and 811a success code is returned to the calling function. If this function returns \textbf{MP\_OKAY} it is safe to assume the 812mp\_int structure has been properly initialized and is safe to use with other functions within the library. 813 814\subsection{Clearing an mp\_int} 815When an mp\_int is no longer required by the application, the memory that has been allocated for its digits must be 816returned to the application's memory pool with the mp\_clear algorithm. 817 818\begin{figure}[here] 819\begin{center} 820\begin{tabular}{l} 821\hline Algorithm \textbf{mp\_clear}. \\ 822\textbf{Input}. An mp\_int $a$ \\ 823\textbf{Output}. The memory for $a$ shall be deallocated. \\ 824\hline \\ 8251. If $a$ has been previously freed then return(\textit{MP\_OKAY}). \\ 8262. for $n$ from 0 to $a.used - 1$ do \\ 827\hspace{3mm}2.1 $a_n \leftarrow 0$ \\ 8283. Free the memory allocated for the digits of $a$. \\ 8294. $a.used \leftarrow 0$ \\ 8305. $a.alloc \leftarrow 0$ \\ 8316. $a.sign \leftarrow MP\_ZPOS$ \\ 8327. Return(\textit{MP\_OKAY}). \\ 833\hline 834\end{tabular} 835\end{center} 836\caption{Algorithm mp\_clear} 837\end{figure} 838 839\textbf{Algorithm mp\_clear.} 840This algorithm accomplishes two goals. First, it clears the digits and the other mp\_int members. This ensures that 841if a developer accidentally re-uses a cleared structure it is less likely to cause problems. The second goal 842is to free the allocated memory. 843 844The logic behind the algorithm is extended by marking cleared mp\_int structures so that subsequent calls to this 845algorithm will not try to free the memory multiple times. Cleared mp\_ints are detectable by having a pre-defined invalid 846digit pointer \textbf{dp} setting. 847 848Once an mp\_int has been cleared the mp\_int structure is no longer in a valid state for any other algorithm 849with the exception of algorithms mp\_init, mp\_init\_copy, mp\_init\_size and mp\_clear. 850 851\vspace{+3mm}\begin{small} 852\hspace{-5.1mm}{\bf File}: bn\_mp\_clear.c 853\vspace{-3mm} 854\begin{alltt} 855\end{alltt} 856\end{small} 857 858The algorithm only operates on the mp\_int if it hasn't been previously cleared. The if statement (line 25) 859checks to see if the \textbf{dp} member is not \textbf{NULL}. If the mp\_int is a valid mp\_int then \textbf{dp} cannot be 860\textbf{NULL} in which case the if statement will evaluate to true. 861 862The digits of the mp\_int are cleared by the for loop (line 27) which assigns a zero to every digit. Similar to mp\_init() 863the digits are assigned zero instead of using block memory operations (such as memset()) since this is more portable. 864 865The digits are deallocated off the heap via the XFREE macro. Similar to XMALLOC the XFREE macro actually evaluates to 866a standard C library function. In this case the free() function. Since free() only deallocates the memory the pointer 867still has to be reset to \textbf{NULL} manually (line 35). 868 869Now that the digits have been cleared and deallocated the other members are set to their final values (lines 36 and 37). 870 871\section{Maintenance Algorithms} 872 873The previous sections describes how to initialize and clear an mp\_int structure. To further support operations 874that are to be performed on mp\_int structures (such as addition and multiplication) the dependent algorithms must be 875able to augment the precision of an mp\_int and 876initialize mp\_ints with differing initial conditions. 877 878These algorithms complete the set of low level algorithms required to work with mp\_int structures in the higher level 879algorithms such as addition, multiplication and modular exponentiation. 880 881\subsection{Augmenting an mp\_int's Precision} 882When storing a value in an mp\_int structure, a sufficient number of digits must be available to accomodate the entire 883result of an operation without loss of precision. Quite often the size of the array given by the \textbf{alloc} member 884is large enough to simply increase the \textbf{used} digit count. However, when the size of the array is too small it 885must be re-sized appropriately to accomodate the result. The mp\_grow algorithm will provide this functionality. 886 887\newpage\begin{figure}[here] 888\begin{center} 889\begin{tabular}{l} 890\hline Algorithm \textbf{mp\_grow}. \\ 891\textbf{Input}. An mp\_int $a$ and an integer $b$. \\ 892\textbf{Output}. $a$ is expanded to accomodate $b$ digits. \\ 893\hline \\ 8941. if $a.alloc \ge b$ then return(\textit{MP\_OKAY}) \\ 8952. $u \leftarrow b\mbox{ (mod }MP\_PREC\mbox{)}$ \\ 8963. $v \leftarrow b + 2 \cdot MP\_PREC - u$ \\ 8974. Re-allocate the array of digits $a$ to size $v$ \\ 8985. If the allocation failed then return(\textit{MP\_MEM}). \\ 8996. for n from a.alloc to $v - 1$ do \\ 900\hspace{+3mm}6.1 $a_n \leftarrow 0$ \\ 9017. $a.alloc \leftarrow v$ \\ 9028. Return(\textit{MP\_OKAY}) \\ 903\hline 904\end{tabular} 905\end{center} 906\caption{Algorithm mp\_grow} 907\end{figure} 908 909\textbf{Algorithm mp\_grow.} 910It is ideal to prevent re-allocations from being performed if they are not required (step one). This is useful to 911prevent mp\_ints from growing excessively in code that erroneously calls mp\_grow. 912 913The requested digit count is padded up to next multiple of \textbf{MP\_PREC} plus an additional \textbf{MP\_PREC} (steps two and three). 914This helps prevent many trivial reallocations that would grow an mp\_int by trivially small values. 915 916It is assumed that the reallocation (step four) leaves the lower $a.alloc$ digits of the mp\_int intact. This is much 917akin to how the \textit{realloc} function from the standard C library works. Since the newly allocated digits are 918assumed to contain undefined values they are initially set to zero. 919 920\vspace{+3mm}\begin{small} 921\hspace{-5.1mm}{\bf File}: bn\_mp\_grow.c 922\vspace{-3mm} 923\begin{alltt} 924\end{alltt} 925\end{small} 926 927A quick optimization is to first determine if a memory re-allocation is required at all. The if statement (line 24) checks 928if the \textbf{alloc} member of the mp\_int is smaller than the requested digit count. If the count is not larger than \textbf{alloc} 929the function skips the re-allocation part thus saving time. 930 931When a re-allocation is performed it is turned into an optimal request to save time in the future. The requested digit count is 932padded upwards to 2nd multiple of \textbf{MP\_PREC} larger than \textbf{alloc} (line 25). The XREALLOC function is used 933to re-allocate the memory. As per the other functions XREALLOC is actually a macro which evaluates to realloc by default. The realloc 934function leaves the base of the allocation intact which means the first \textbf{alloc} digits of the mp\_int are the same as before 935the re-allocation. All that is left is to clear the newly allocated digits and return. 936 937Note that the re-allocation result is actually stored in a temporary pointer $tmp$. This is to allow this function to return 938an error with a valid pointer. Earlier releases of the library stored the result of XREALLOC into the mp\_int $a$. That would 939result in a memory leak if XREALLOC ever failed. 940 941\subsection{Initializing Variable Precision mp\_ints} 942Occasionally the number of digits required will be known in advance of an initialization, based on, for example, the size 943of input mp\_ints to a given algorithm. The purpose of algorithm mp\_init\_size is similar to mp\_init except that it 944will allocate \textit{at least} a specified number of digits. 945 946\begin{figure}[here] 947\begin{small} 948\begin{center} 949\begin{tabular}{l} 950\hline Algorithm \textbf{mp\_init\_size}. \\ 951\textbf{Input}. An mp\_int $a$ and the requested number of digits $b$. \\ 952\textbf{Output}. $a$ is initialized to hold at least $b$ digits. \\ 953\hline \\ 9541. $u \leftarrow b \mbox{ (mod }MP\_PREC\mbox{)}$ \\ 9552. $v \leftarrow b + 2 \cdot MP\_PREC - u$ \\ 9563. Allocate $v$ digits. \\ 9574. for $n$ from $0$ to $v - 1$ do \\ 958\hspace{3mm}4.1 $a_n \leftarrow 0$ \\ 9595. $a.sign \leftarrow MP\_ZPOS$\\ 9606. $a.used \leftarrow 0$\\ 9617. $a.alloc \leftarrow v$\\ 9628. Return(\textit{MP\_OKAY})\\ 963\hline 964\end{tabular} 965\end{center} 966\end{small} 967\caption{Algorithm mp\_init\_size} 968\end{figure} 969 970\textbf{Algorithm mp\_init\_size.} 971This algorithm will initialize an mp\_int structure $a$ like algorithm mp\_init with the exception that the number of 972digits allocated can be controlled by the second input argument $b$. The input size is padded upwards so it is a 973multiple of \textbf{MP\_PREC} plus an additional \textbf{MP\_PREC} digits. This padding is used to prevent trivial 974allocations from becoming a bottleneck in the rest of the algorithms. 975 976Like algorithm mp\_init, the mp\_int structure is initialized to a default state representing the integer zero. This 977particular algorithm is useful if it is known ahead of time the approximate size of the input. If the approximation is 978correct no further memory re-allocations are required to work with the mp\_int. 979 980\vspace{+3mm}\begin{small} 981\hspace{-5.1mm}{\bf File}: bn\_mp\_init\_size.c 982\vspace{-3mm} 983\begin{alltt} 984\end{alltt} 985\end{small} 986 987The number of digits $b$ requested is padded (line 24) by first augmenting it to the next multiple of 988\textbf{MP\_PREC} and then adding \textbf{MP\_PREC} to the result. If the memory can be successfully allocated the 989mp\_int is placed in a default state representing the integer zero. Otherwise, the error code \textbf{MP\_MEM} will be 990returned (line 29). 991 992The digits are allocated and set to zero at the same time with the calloc() function (line @25,XCALLOC@). The 993\textbf{used} count is set to zero, the \textbf{alloc} count set to the padded digit count and the \textbf{sign} flag set 994to \textbf{MP\_ZPOS} to achieve a default valid mp\_int state (lines 33, 34 and 35). If the function 995returns succesfully then it is correct to assume that the mp\_int structure is in a valid state for the remainder of the 996functions to work with. 997 998\subsection{Multiple Integer Initializations and Clearings} 999Occasionally a function will require a series of mp\_int data types to be made available simultaneously. 1000The purpose of algorithm mp\_init\_multi is to initialize a variable length array of mp\_int structures in a single 1001statement. It is essentially a shortcut to multiple initializations. 1002 1003\newpage\begin{figure}[here] 1004\begin{center} 1005\begin{tabular}{l} 1006\hline Algorithm \textbf{mp\_init\_multi}. \\ 1007\textbf{Input}. Variable length array $V_k$ of mp\_int variables of length $k$. \\ 1008\textbf{Output}. The array is initialized such that each mp\_int of $V_k$ is ready to use. \\ 1009\hline \\ 10101. for $n$ from 0 to $k - 1$ do \\ 1011\hspace{+3mm}1.1. Initialize the mp\_int $V_n$ (\textit{mp\_init}) \\ 1012\hspace{+3mm}1.2. If initialization failed then do \\ 1013\hspace{+6mm}1.2.1. for $j$ from $0$ to $n$ do \\ 1014\hspace{+9mm}1.2.1.1. Free the mp\_int $V_j$ (\textit{mp\_clear}) \\ 1015\hspace{+6mm}1.2.2. Return(\textit{MP\_MEM}) \\ 10162. Return(\textit{MP\_OKAY}) \\ 1017\hline 1018\end{tabular} 1019\end{center} 1020\caption{Algorithm mp\_init\_multi} 1021\end{figure} 1022 1023\textbf{Algorithm mp\_init\_multi.} 1024The algorithm will initialize the array of mp\_int variables one at a time. If a runtime error has been detected 1025(\textit{step 1.2}) all of the previously initialized variables are cleared. The goal is an ``all or nothing'' 1026initialization which allows for quick recovery from runtime errors. 1027 1028\vspace{+3mm}\begin{small} 1029\hspace{-5.1mm}{\bf File}: bn\_mp\_init\_multi.c 1030\vspace{-3mm} 1031\begin{alltt} 1032\end{alltt} 1033\end{small} 1034 1035This function intializes a variable length list of mp\_int structure pointers. However, instead of having the mp\_int 1036structures in an actual C array they are simply passed as arguments to the function. This function makes use of the 1037``...'' argument syntax of the C programming language. The list is terminated with a final \textbf{NULL} argument 1038appended on the right. 1039 1040The function uses the ``stdarg.h'' \textit{va} functions to step portably through the arguments to the function. A count 1041$n$ of succesfully initialized mp\_int structures is maintained (line 48) such that if a failure does occur, 1042the algorithm can backtrack and free the previously initialized structures (lines 28 to 47). 1043 1044 1045\subsection{Clamping Excess Digits} 1046When a function anticipates a result will be $n$ digits it is simpler to assume this is true within the body of 1047the function instead of checking during the computation. For example, a multiplication of a $i$ digit number by a 1048$j$ digit produces a result of at most $i + j$ digits. It is entirely possible that the result is $i + j - 1$ 1049though, with no final carry into the last position. However, suppose the destination had to be first expanded 1050(\textit{via mp\_grow}) to accomodate $i + j - 1$ digits than further expanded to accomodate the final carry. 1051That would be a considerable waste of time since heap operations are relatively slow. 1052 1053The ideal solution is to always assume the result is $i + j$ and fix up the \textbf{used} count after the function 1054terminates. This way a single heap operation (\textit{at most}) is required. However, if the result was not checked 1055there would be an excess high order zero digit. 1056 1057For example, suppose the product of two integers was $x_n = (0x_{n-1}x_{n-2}...x_0)_{\beta}$. The leading zero digit 1058will not contribute to the precision of the result. In fact, through subsequent operations more leading zero digits would 1059accumulate to the point the size of the integer would be prohibitive. As a result even though the precision is very 1060low the representation is excessively large. 1061 1062The mp\_clamp algorithm is designed to solve this very problem. It will trim high-order zeros by decrementing the 1063\textbf{used} count until a non-zero most significant digit is found. Also in this system, zero is considered to be a 1064positive number which means that if the \textbf{used} count is decremented to zero, the sign must be set to 1065\textbf{MP\_ZPOS}. 1066 1067\begin{figure}[here] 1068\begin{center} 1069\begin{tabular}{l} 1070\hline Algorithm \textbf{mp\_clamp}. \\ 1071\textbf{Input}. An mp\_int $a$ \\ 1072\textbf{Output}. Any excess leading zero digits of $a$ are removed \\ 1073\hline \\ 10741. while $a.used > 0$ and $a_{a.used - 1} = 0$ do \\ 1075\hspace{+3mm}1.1 $a.used \leftarrow a.used - 1$ \\ 10762. if $a.used = 0$ then do \\ 1077\hspace{+3mm}2.1 $a.sign \leftarrow MP\_ZPOS$ \\ 1078\hline \\ 1079\end{tabular} 1080\end{center} 1081\caption{Algorithm mp\_clamp} 1082\end{figure} 1083 1084\textbf{Algorithm mp\_clamp.} 1085As can be expected this algorithm is very simple. The loop on step one is expected to iterate only once or twice at 1086the most. For example, this will happen in cases where there is not a carry to fill the last position. Step two fixes the sign for 1087when all of the digits are zero to ensure that the mp\_int is valid at all times. 1088 1089\vspace{+3mm}\begin{small} 1090\hspace{-5.1mm}{\bf File}: bn\_mp\_clamp.c 1091\vspace{-3mm} 1092\begin{alltt} 1093\end{alltt} 1094\end{small} 1095 1096Note on line 28 how to test for the \textbf{used} count is made on the left of the \&\& operator. In the C programming 1097language the terms to \&\& are evaluated left to right with a boolean short-circuit if any condition fails. This is 1098important since if the \textbf{used} is zero the test on the right would fetch below the array. That is obviously 1099undesirable. The parenthesis on line 31 is used to make sure the \textbf{used} count is decremented and not 1100the pointer ``a''. 1101 1102\section*{Exercises} 1103\begin{tabular}{cl} 1104$\left [ 1 \right ]$ & Discuss the relevance of the \textbf{used} member of the mp\_int structure. \\ 1105 & \\ 1106$\left [ 1 \right ]$ & Discuss the consequences of not using padding when performing allocations. \\ 1107 & \\ 1108$\left [ 2 \right ]$ & Estimate an ideal value for \textbf{MP\_PREC} when performing 1024-bit RSA \\ 1109 & encryption when $\beta = 2^{28}$. \\ 1110 & \\ 1111$\left [ 1 \right ]$ & Discuss the relevance of the algorithm mp\_clamp. What does it prevent? \\ 1112 & \\ 1113$\left [ 1 \right ]$ & Give an example of when the algorithm mp\_init\_copy might be useful. \\ 1114 & \\ 1115\end{tabular} 1116 1117 1118%%% 1119% CHAPTER FOUR 1120%%% 1121 1122\chapter{Basic Operations} 1123 1124\section{Introduction} 1125In the previous chapter a series of low level algorithms were established that dealt with initializing and maintaining 1126mp\_int structures. This chapter will discuss another set of seemingly non-algebraic algorithms which will form the low 1127level basis of the entire library. While these algorithm are relatively trivial it is important to understand how they 1128work before proceeding since these algorithms will be used almost intrinsically in the following chapters. 1129 1130The algorithms in this chapter deal primarily with more ``programmer'' related tasks such as creating copies of 1131mp\_int structures, assigning small values to mp\_int structures and comparisons of the values mp\_int structures 1132represent. 1133 1134\section{Assigning Values to mp\_int Structures} 1135\subsection{Copying an mp\_int} 1136Assigning the value that a given mp\_int structure represents to another mp\_int structure shall be known as making 1137a copy for the purposes of this text. The copy of the mp\_int will be a separate entity that represents the same 1138value as the mp\_int it was copied from. The mp\_copy algorithm provides this functionality. 1139 1140\newpage\begin{figure}[here] 1141\begin{center} 1142\begin{tabular}{l} 1143\hline Algorithm \textbf{mp\_copy}. \\ 1144\textbf{Input}. An mp\_int $a$ and $b$. \\ 1145\textbf{Output}. Store a copy of $a$ in $b$. \\ 1146\hline \\ 11471. If $b.alloc < a.used$ then grow $b$ to $a.used$ digits. (\textit{mp\_grow}) \\ 11482. for $n$ from 0 to $a.used - 1$ do \\ 1149\hspace{3mm}2.1 $b_{n} \leftarrow a_{n}$ \\ 11503. for $n$ from $a.used$ to $b.used - 1$ do \\ 1151\hspace{3mm}3.1 $b_{n} \leftarrow 0$ \\ 11524. $b.used \leftarrow a.used$ \\ 11535. $b.sign \leftarrow a.sign$ \\ 11546. return(\textit{MP\_OKAY}) \\ 1155\hline 1156\end{tabular} 1157\end{center} 1158\caption{Algorithm mp\_copy} 1159\end{figure} 1160 1161\textbf{Algorithm mp\_copy.} 1162This algorithm copies the mp\_int $a$ such that upon succesful termination of the algorithm the mp\_int $b$ will 1163represent the same integer as the mp\_int $a$. The mp\_int $b$ shall be a complete and distinct copy of the 1164mp\_int $a$ meaing that the mp\_int $a$ can be modified and it shall not affect the value of the mp\_int $b$. 1165 1166If $b$ does not have enough room for the digits of $a$ it must first have its precision augmented via the mp\_grow 1167algorithm. The digits of $a$ are copied over the digits of $b$ and any excess digits of $b$ are set to zero (step two 1168and three). The \textbf{used} and \textbf{sign} members of $a$ are finally copied over the respective members of 1169$b$. 1170 1171\textbf{Remark.} This algorithm also introduces a new idiosyncrasy that will be used throughout the rest of the 1172text. The error return codes of other algorithms are not explicitly checked in the pseudo-code presented. For example, in 1173step one of the mp\_copy algorithm the return of mp\_grow is not explicitly checked to ensure it succeeded. Text space is 1174limited so it is assumed that if a algorithm fails it will clear all temporarily allocated mp\_ints and return 1175the error code itself. However, the C code presented will demonstrate all of the error handling logic required to 1176implement the pseudo-code. 1177 1178\vspace{+3mm}\begin{small} 1179\hspace{-5.1mm}{\bf File}: bn\_mp\_copy.c 1180\vspace{-3mm} 1181\begin{alltt} 1182\end{alltt} 1183\end{small} 1184 1185Occasionally a dependent algorithm may copy an mp\_int effectively into itself such as when the input and output 1186mp\_int structures passed to a function are one and the same. For this case it is optimal to return immediately without 1187copying digits (line 25). 1188 1189The mp\_int $b$ must have enough digits to accomodate the used digits of the mp\_int $a$. If $b.alloc$ is less than 1190$a.used$ the algorithm mp\_grow is used to augment the precision of $b$ (lines 30 to 33). In order to 1191simplify the inner loop that copies the digits from $a$ to $b$, two aliases $tmpa$ and $tmpb$ point directly at the digits 1192of the mp\_ints $a$ and $b$ respectively. These aliases (lines 43 and 46) allow the compiler to access the digits without first dereferencing the 1193mp\_int pointers and then subsequently the pointer to the digits. 1194 1195After the aliases are established the digits from $a$ are copied into $b$ (lines 49 to 51) and then the excess 1196digits of $b$ are set to zero (lines 54 to 56). Both ``for'' loops make use of the pointer aliases and in 1197fact the alias for $b$ is carried through into the second ``for'' loop to clear the excess digits. This optimization 1198allows the alias to stay in a machine register fairly easy between the two loops. 1199 1200\textbf{Remarks.} The use of pointer aliases is an implementation methodology first introduced in this function that will 1201be used considerably in other functions. Technically, a pointer alias is simply a short hand alias used to lower the 1202number of pointer dereferencing operations required to access data. For example, a for loop may resemble 1203 1204\begin{alltt} 1205for (x = 0; x < 100; x++) \{ 1206 a->num[4]->dp[x] = 0; 1207\} 1208\end{alltt} 1209 1210This could be re-written using aliases as 1211 1212\begin{alltt} 1213mp_digit *tmpa; 1214a = a->num[4]->dp; 1215for (x = 0; x < 100; x++) \{ 1216 *a++ = 0; 1217\} 1218\end{alltt} 1219 1220In this case an alias is used to access the 1221array of digits within an mp\_int structure directly. It may seem that a pointer alias is strictly not required 1222as a compiler may optimize out the redundant pointer operations. However, there are two dominant reasons to use aliases. 1223 1224The first reason is that most compilers will not effectively optimize pointer arithmetic. For example, some optimizations 1225may work for the Microsoft Visual C++ compiler (MSVC) and not for the GNU C Compiler (GCC). Also some optimizations may 1226work for GCC and not MSVC. As such it is ideal to find a common ground for as many compilers as possible. Pointer 1227aliases optimize the code considerably before the compiler even reads the source code which means the end compiled code 1228stands a better chance of being faster. 1229 1230The second reason is that pointer aliases often can make an algorithm simpler to read. Consider the first ``for'' 1231loop of the function mp\_copy() re-written to not use pointer aliases. 1232 1233\begin{alltt} 1234 /* copy all the digits */ 1235 for (n = 0; n < a->used; n++) \{ 1236 b->dp[n] = a->dp[n]; 1237 \} 1238\end{alltt} 1239 1240Whether this code is harder to read depends strongly on the individual. However, it is quantifiably slightly more 1241complicated as there are four variables within the statement instead of just two. 1242 1243\subsubsection{Nested Statements} 1244Another commonly used technique in the source routines is that certain sections of code are nested. This is used in 1245particular with the pointer aliases to highlight code phases. For example, a Comba multiplier (discussed in chapter six) 1246will typically have three different phases. First the temporaries are initialized, then the columns calculated and 1247finally the carries are propagated. In this example the middle column production phase will typically be nested as it 1248uses temporary variables and aliases the most. 1249 1250The nesting also simplies the source code as variables that are nested are only valid for their scope. As a result 1251the various temporary variables required do not propagate into other sections of code. 1252 1253 1254\subsection{Creating a Clone} 1255Another common operation is to make a local temporary copy of an mp\_int argument. To initialize an mp\_int 1256and then copy another existing mp\_int into the newly intialized mp\_int will be known as creating a clone. This is 1257useful within functions that need to modify an argument but do not wish to actually modify the original copy. The 1258mp\_init\_copy algorithm has been designed to help perform this task. 1259 1260\begin{figure}[here] 1261\begin{center} 1262\begin{tabular}{l} 1263\hline Algorithm \textbf{mp\_init\_copy}. \\ 1264\textbf{Input}. An mp\_int $a$ and $b$\\ 1265\textbf{Output}. $a$ is initialized to be a copy of $b$. \\ 1266\hline \\ 12671. Init $a$. (\textit{mp\_init}) \\ 12682. Copy $b$ to $a$. (\textit{mp\_copy}) \\ 12693. Return the status of the copy operation. \\ 1270\hline 1271\end{tabular} 1272\end{center} 1273\caption{Algorithm mp\_init\_copy} 1274\end{figure} 1275 1276\textbf{Algorithm mp\_init\_copy.} 1277This algorithm will initialize an mp\_int variable and copy another previously initialized mp\_int variable into it. As 1278such this algorithm will perform two operations in one step. 1279 1280\vspace{+3mm}\begin{small} 1281\hspace{-5.1mm}{\bf File}: bn\_mp\_init\_copy.c 1282\vspace{-3mm} 1283\begin{alltt} 1284\end{alltt} 1285\end{small} 1286 1287This will initialize \textbf{a} and make it a verbatim copy of the contents of \textbf{b}. Note that 1288\textbf{a} will have its own memory allocated which means that \textbf{b} may be cleared after the call 1289and \textbf{a} will be left intact. 1290 1291\section{Zeroing an Integer} 1292Reseting an mp\_int to the default state is a common step in many algorithms. The mp\_zero algorithm will be the algorithm used to 1293perform this task. 1294 1295\begin{figure}[here] 1296\begin{center} 1297\begin{tabular}{l} 1298\hline Algorithm \textbf{mp\_zero}. \\ 1299\textbf{Input}. An mp\_int $a$ \\ 1300\textbf{Output}. Zero the contents of $a$ \\ 1301\hline \\ 13021. $a.used \leftarrow 0$ \\ 13032. $a.sign \leftarrow$ MP\_ZPOS \\ 13043. for $n$ from 0 to $a.alloc - 1$ do \\ 1305\hspace{3mm}3.1 $a_n \leftarrow 0$ \\ 1306\hline 1307\end{tabular} 1308\end{center} 1309\caption{Algorithm mp\_zero} 1310\end{figure} 1311 1312\textbf{Algorithm mp\_zero.} 1313This algorithm simply resets a mp\_int to the default state. 1314 1315\vspace{+3mm}\begin{small} 1316\hspace{-5.1mm}{\bf File}: bn\_mp\_zero.c 1317\vspace{-3mm} 1318\begin{alltt} 1319\end{alltt} 1320\end{small} 1321 1322After the function is completed, all of the digits are zeroed, the \textbf{used} count is zeroed and the 1323\textbf{sign} variable is set to \textbf{MP\_ZPOS}. 1324 1325\section{Sign Manipulation} 1326\subsection{Absolute Value} 1327With the mp\_int representation of an integer, calculating the absolute value is trivial. The mp\_abs algorithm will compute 1328the absolute value of an mp\_int. 1329 1330\begin{figure}[here] 1331\begin{center} 1332\begin{tabular}{l} 1333\hline Algorithm \textbf{mp\_abs}. \\ 1334\textbf{Input}. An mp\_int $a$ \\ 1335\textbf{Output}. Computes $b = \vert a \vert$ \\ 1336\hline \\ 13371. Copy $a$ to $b$. (\textit{mp\_copy}) \\ 13382. If the copy failed return(\textit{MP\_MEM}). \\ 13393. $b.sign \leftarrow MP\_ZPOS$ \\ 13404. Return(\textit{MP\_OKAY}) \\ 1341\hline 1342\end{tabular} 1343\end{center} 1344\caption{Algorithm mp\_abs} 1345\end{figure} 1346 1347\textbf{Algorithm mp\_abs.} 1348This algorithm computes the absolute of an mp\_int input. First it copies $a$ over $b$. This is an example of an 1349algorithm where the check in mp\_copy that determines if the source and destination are equal proves useful. This allows, 1350for instance, the developer to pass the same mp\_int as the source and destination to this function without addition 1351logic to handle it. 1352 1353\vspace{+3mm}\begin{small} 1354\hspace{-5.1mm}{\bf File}: bn\_mp\_abs.c 1355\vspace{-3mm} 1356\begin{alltt} 1357\end{alltt} 1358\end{small} 1359 1360This fairly trivial algorithm first eliminates non--required duplications (line 28) and then sets the 1361\textbf{sign} flag to \textbf{MP\_ZPOS}. 1362 1363\subsection{Integer Negation} 1364With the mp\_int representation of an integer, calculating the negation is also trivial. The mp\_neg algorithm will compute 1365the negative of an mp\_int input. 1366 1367\begin{figure}[here] 1368\begin{center} 1369\begin{tabular}{l} 1370\hline Algorithm \textbf{mp\_neg}. \\ 1371\textbf{Input}. An mp\_int $a$ \\ 1372\textbf{Output}. Computes $b = -a$ \\ 1373\hline \\ 13741. Copy $a$ to $b$. (\textit{mp\_copy}) \\ 13752. If the copy failed return(\textit{MP\_MEM}). \\ 13763. If $a.used = 0$ then return(\textit{MP\_OKAY}). \\ 13774. If $a.sign = MP\_ZPOS$ then do \\ 1378\hspace{3mm}4.1 $b.sign = MP\_NEG$. \\ 13795. else do \\ 1380\hspace{3mm}5.1 $b.sign = MP\_ZPOS$. \\ 13816. Return(\textit{MP\_OKAY}) \\ 1382\hline 1383\end{tabular} 1384\end{center} 1385\caption{Algorithm mp\_neg} 1386\end{figure} 1387 1388\textbf{Algorithm mp\_neg.} 1389This algorithm computes the negation of an input. First it copies $a$ over $b$. If $a$ has no used digits then 1390the algorithm returns immediately. Otherwise it flips the sign flag and stores the result in $b$. Note that if 1391$a$ had no digits then it must be positive by definition. Had step three been omitted then the algorithm would return 1392zero as negative. 1393 1394\vspace{+3mm}\begin{small} 1395\hspace{-5.1mm}{\bf File}: bn\_mp\_neg.c 1396\vspace{-3mm} 1397\begin{alltt} 1398\end{alltt} 1399\end{small} 1400 1401Like mp\_abs() this function avoids non--required duplications (line 22) and then sets the sign. We 1402have to make sure that only non--zero values get a \textbf{sign} of \textbf{MP\_NEG}. If the mp\_int is zero 1403than the \textbf{sign} is hard--coded to \textbf{MP\_ZPOS}. 1404 1405\section{Small Constants} 1406\subsection{Setting Small Constants} 1407Often a mp\_int must be set to a relatively small value such as $1$ or $2$. For these cases the mp\_set algorithm is useful. 1408 1409\newpage\begin{figure}[here] 1410\begin{center} 1411\begin{tabular}{l} 1412\hline Algorithm \textbf{mp\_set}. \\ 1413\textbf{Input}. An mp\_int $a$ and a digit $b$ \\ 1414\textbf{Output}. Make $a$ equivalent to $b$ \\ 1415\hline \\ 14161. Zero $a$ (\textit{mp\_zero}). \\ 14172. $a_0 \leftarrow b \mbox{ (mod }\beta\mbox{)}$ \\ 14183. $a.used \leftarrow \left \lbrace \begin{array}{ll} 1419 1 & \mbox{if }a_0 > 0 \\ 1420 0 & \mbox{if }a_0 = 0 1421 \end{array} \right .$ \\ 1422\hline 1423\end{tabular} 1424\end{center} 1425\caption{Algorithm mp\_set} 1426\end{figure} 1427 1428\textbf{Algorithm mp\_set.} 1429This algorithm sets a mp\_int to a small single digit value. Step number 1 ensures that the integer is reset to the default state. The 1430single digit is set (\textit{modulo $\beta$}) and the \textbf{used} count is adjusted accordingly. 1431 1432\vspace{+3mm}\begin{small} 1433\hspace{-5.1mm}{\bf File}: bn\_mp\_set.c 1434\vspace{-3mm} 1435\begin{alltt} 1436\end{alltt} 1437\end{small} 1438 1439First we zero (line 21) the mp\_int to make sure that the other members are initialized for a 1440small positive constant. mp\_zero() ensures that the \textbf{sign} is positive and the \textbf{used} count 1441is zero. Next we set the digit and reduce it modulo $\beta$ (line 22). After this step we have to 1442check if the resulting digit is zero or not. If it is not then we set the \textbf{used} count to one, otherwise 1443to zero. 1444 1445We can quickly reduce modulo $\beta$ since it is of the form $2^k$ and a quick binary AND operation with 1446$2^k - 1$ will perform the same operation. 1447 1448One important limitation of this function is that it will only set one digit. The size of a digit is not fixed, meaning source that uses 1449this function should take that into account. Only trivially small constants can be set using this function. 1450 1451\subsection{Setting Large Constants} 1452To overcome the limitations of the mp\_set algorithm the mp\_set\_int algorithm is ideal. It accepts a ``long'' 1453data type as input and will always treat it as a 32-bit integer. 1454 1455\begin{figure}[here] 1456\begin{center} 1457\begin{tabular}{l} 1458\hline Algorithm \textbf{mp\_set\_int}. \\ 1459\textbf{Input}. An mp\_int $a$ and a ``long'' integer $b$ \\ 1460\textbf{Output}. Make $a$ equivalent to $b$ \\ 1461\hline \\ 14621. Zero $a$ (\textit{mp\_zero}) \\ 14632. for $n$ from 0 to 7 do \\ 1464\hspace{3mm}2.1 $a \leftarrow a \cdot 16$ (\textit{mp\_mul2d}) \\ 1465\hspace{3mm}2.2 $u \leftarrow \lfloor b / 2^{4(7 - n)} \rfloor \mbox{ (mod }16\mbox{)}$\\ 1466\hspace{3mm}2.3 $a_0 \leftarrow a_0 + u$ \\ 1467\hspace{3mm}2.4 $a.used \leftarrow a.used + 1$ \\ 14683. Clamp excess used digits (\textit{mp\_clamp}) \\ 1469\hline 1470\end{tabular} 1471\end{center} 1472\caption{Algorithm mp\_set\_int} 1473\end{figure} 1474 1475\textbf{Algorithm mp\_set\_int.} 1476The algorithm performs eight iterations of a simple loop where in each iteration four bits from the source are added to the 1477mp\_int. Step 2.1 will multiply the current result by sixteen making room for four more bits in the less significant positions. In step 2.2 the 1478next four bits from the source are extracted and are added to the mp\_int. The \textbf{used} digit count is 1479incremented to reflect the addition. The \textbf{used} digit counter is incremented since if any of the leading digits were zero the mp\_int would have 1480zero digits used and the newly added four bits would be ignored. 1481 1482Excess zero digits are trimmed in steps 2.1 and 3 by using higher level algorithms mp\_mul2d and mp\_clamp. 1483 1484\vspace{+3mm}\begin{small} 1485\hspace{-5.1mm}{\bf File}: bn\_mp\_set\_int.c 1486\vspace{-3mm} 1487\begin{alltt} 1488\end{alltt} 1489\end{small} 1490 1491This function sets four bits of the number at a time to handle all practical \textbf{DIGIT\_BIT} sizes. The weird 1492addition on line 39 ensures that the newly added in bits are added to the number of digits. While it may not 1493seem obvious as to why the digit counter does not grow exceedingly large it is because of the shift on line 28 1494as well as the call to mp\_clamp() on line 41. Both functions will clamp excess leading digits which keeps 1495the number of used digits low. 1496 1497\section{Comparisons} 1498\subsection{Unsigned Comparisions} 1499Comparing a multiple precision integer is performed with the exact same algorithm used to compare two decimal numbers. For example, 1500to compare $1,234$ to $1,264$ the digits are extracted by their positions. That is we compare $1 \cdot 10^3 + 2 \cdot 10^2 + 3 \cdot 10^1 + 4 \cdot 10^0$ 1501to $1 \cdot 10^3 + 2 \cdot 10^2 + 6 \cdot 10^1 + 4 \cdot 10^0$ by comparing single digits at a time starting with the highest magnitude 1502positions. If any leading digit of one integer is greater than a digit in the same position of another integer then obviously it must be greater. 1503 1504The first comparision routine that will be developed is the unsigned magnitude compare which will perform a comparison based on the digits of two 1505mp\_int variables alone. It will ignore the sign of the two inputs. Such a function is useful when an absolute comparison is required or if the 1506signs are known to agree in advance. 1507 1508To facilitate working with the results of the comparison functions three constants are required. 1509 1510\begin{figure}[here] 1511\begin{center} 1512\begin{tabular}{|r|l|} 1513\hline \textbf{Constant} & \textbf{Meaning} \\ 1514\hline \textbf{MP\_GT} & Greater Than \\ 1515\hline \textbf{MP\_EQ} & Equal To \\ 1516\hline \textbf{MP\_LT} & Less Than \\ 1517\hline 1518\end{tabular} 1519\end{center} 1520\caption{Comparison Return Codes} 1521\end{figure} 1522 1523\begin{figure}[here] 1524\begin{center} 1525\begin{tabular}{l} 1526\hline Algorithm \textbf{mp\_cmp\_mag}. \\ 1527\textbf{Input}. Two mp\_ints $a$ and $b$. \\ 1528\textbf{Output}. Unsigned comparison results ($a$ to the left of $b$). \\ 1529\hline \\ 15301. If $a.used > b.used$ then return(\textit{MP\_GT}) \\ 15312. If $a.used < b.used$ then return(\textit{MP\_LT}) \\ 15323. for n from $a.used - 1$ to 0 do \\ 1533\hspace{+3mm}3.1 if $a_n > b_n$ then return(\textit{MP\_GT}) \\ 1534\hspace{+3mm}3.2 if $a_n < b_n$ then return(\textit{MP\_LT}) \\ 15354. Return(\textit{MP\_EQ}) \\ 1536\hline 1537\end{tabular} 1538\end{center} 1539\caption{Algorithm mp\_cmp\_mag} 1540\end{figure} 1541 1542\textbf{Algorithm mp\_cmp\_mag.} 1543By saying ``$a$ to the left of $b$'' it is meant that the comparison is with respect to $a$, that is if $a$ is greater than $b$ it will return 1544\textbf{MP\_GT} and similar with respect to when $a = b$ and $a < b$. The first two steps compare the number of digits used in both $a$ and $b$. 1545Obviously if the digit counts differ there would be an imaginary zero digit in the smaller number where the leading digit of the larger number is. 1546If both have the same number of digits than the actual digits themselves must be compared starting at the leading digit. 1547 1548By step three both inputs must have the same number of digits so its safe to start from either $a.used - 1$ or $b.used - 1$ and count down to 1549the zero'th digit. If after all of the digits have been compared, no difference is found, the algorithm returns \textbf{MP\_EQ}. 1550 1551\vspace{+3mm}\begin{small} 1552\hspace{-5.1mm}{\bf File}: bn\_mp\_cmp\_mag.c 1553\vspace{-3mm} 1554\begin{alltt} 1555\end{alltt} 1556\end{small} 1557 1558The two if statements (lines 25 and 29) compare the number of digits in the two inputs. These two are 1559performed before all of the digits are compared since it is a very cheap test to perform and can potentially save 1560considerable time. The implementation given is also not valid without those two statements. $b.alloc$ may be 1561smaller than $a.used$, meaning that undefined values will be read from $b$ past the end of the array of digits. 1562 1563 1564 1565\subsection{Signed Comparisons} 1566Comparing with sign considerations is also fairly critical in several routines (\textit{division for example}). Based on an unsigned magnitude 1567comparison a trivial signed comparison algorithm can be written. 1568 1569\begin{figure}[here] 1570\begin{center} 1571\begin{tabular}{l} 1572\hline Algorithm \textbf{mp\_cmp}. \\ 1573\textbf{Input}. Two mp\_ints $a$ and $b$ \\ 1574\textbf{Output}. Signed Comparison Results ($a$ to the left of $b$) \\ 1575\hline \\ 15761. if $a.sign = MP\_NEG$ and $b.sign = MP\_ZPOS$ then return(\textit{MP\_LT}) \\ 15772. if $a.sign = MP\_ZPOS$ and $b.sign = MP\_NEG$ then return(\textit{MP\_GT}) \\ 15783. if $a.sign = MP\_NEG$ then \\ 1579\hspace{+3mm}3.1 Return the unsigned comparison of $b$ and $a$ (\textit{mp\_cmp\_mag}) \\ 15804 Otherwise \\ 1581\hspace{+3mm}4.1 Return the unsigned comparison of $a$ and $b$ \\ 1582\hline 1583\end{tabular} 1584\end{center} 1585\caption{Algorithm mp\_cmp} 1586\end{figure} 1587 1588\textbf{Algorithm mp\_cmp.} 1589The first two steps compare the signs of the two inputs. If the signs do not agree then it can return right away with the appropriate 1590comparison code. When the signs are equal the digits of the inputs must be compared to determine the correct result. In step 1591three the unsigned comparision flips the order of the arguments since they are both negative. For instance, if $-a > -b$ then 1592$\vert a \vert < \vert b \vert$. Step number four will compare the two when they are both positive. 1593 1594\vspace{+3mm}\begin{small} 1595\hspace{-5.1mm}{\bf File}: bn\_mp\_cmp.c 1596\vspace{-3mm} 1597\begin{alltt} 1598\end{alltt} 1599\end{small} 1600 1601The two if statements (lines 23 and 24) perform the initial sign comparison. If the signs are not the equal then which ever 1602has the positive sign is larger. The inputs are compared (line 32) based on magnitudes. If the signs were both 1603negative then the unsigned comparison is performed in the opposite direction (line 34). Otherwise, the signs are assumed to 1604be both positive and a forward direction unsigned comparison is performed. 1605 1606\section*{Exercises} 1607\begin{tabular}{cl} 1608$\left [ 2 \right ]$ & Modify algorithm mp\_set\_int to accept as input a variable length array of bits. \\ 1609 & \\ 1610$\left [ 3 \right ]$ & Give the probability that algorithm mp\_cmp\_mag will have to compare $k$ digits \\ 1611 & of two random digits (of equal magnitude) before a difference is found. \\ 1612 & \\ 1613$\left [ 1 \right ]$ & Suggest a simple method to speed up the implementation of mp\_cmp\_mag based \\ 1614 & on the observations made in the previous problem. \\ 1615 & 1616\end{tabular} 1617 1618\chapter{Basic Arithmetic} 1619\section{Introduction} 1620At this point algorithms for initialization, clearing, zeroing, copying, comparing and setting small constants have been 1621established. The next logical set of algorithms to develop are addition, subtraction and digit shifting algorithms. These 1622algorithms make use of the lower level algorithms and are the cruicial building block for the multiplication algorithms. It is very important 1623that these algorithms are highly optimized. On their own they are simple $O(n)$ algorithms but they can be called from higher level algorithms 1624which easily places them at $O(n^2)$ or even $O(n^3)$ work levels. 1625 1626All of the algorithms within this chapter make use of the logical bit shift operations denoted by $<<$ and $>>$ for left and right 1627logical shifts respectively. A logical shift is analogous to sliding the decimal point of radix-10 representations. For example, the real 1628number $0.9345$ is equivalent to $93.45\%$ which is found by sliding the the decimal two places to the right (\textit{multiplying by $\beta^2 = 10^2$}). 1629Algebraically a binary logical shift is equivalent to a division or multiplication by a power of two. 1630For example, $a << k = a \cdot 2^k$ while $a >> k = \lfloor a/2^k \rfloor$. 1631 1632One significant difference between a logical shift and the way decimals are shifted is that digits below the zero'th position are removed 1633from the number. For example, consider $1101_2 >> 1$ using decimal notation this would produce $110.1_2$. However, with a logical shift the 1634result is $110_2$. 1635 1636\section{Addition and Subtraction} 1637In common twos complement fixed precision arithmetic negative numbers are easily represented by subtraction from the modulus. For example, with 32-bit integers 1638$a - b\mbox{ (mod }2^{32}\mbox{)}$ is the same as $a + (2^{32} - b) \mbox{ (mod }2^{32}\mbox{)}$ since $2^{32} \equiv 0 \mbox{ (mod }2^{32}\mbox{)}$. 1639As a result subtraction can be performed with a trivial series of logical operations and an addition. 1640 1641However, in multiple precision arithmetic negative numbers are not represented in the same way. Instead a sign flag is used to keep track of the 1642sign of the integer. As a result signed addition and subtraction are actually implemented as conditional usage of lower level addition or 1643subtraction algorithms with the sign fixed up appropriately. 1644 1645The lower level algorithms will add or subtract integers without regard to the sign flag. That is they will add or subtract the magnitude of 1646the integers respectively. 1647 1648\subsection{Low Level Addition} 1649An unsigned addition of multiple precision integers is performed with the same long-hand algorithm used to add decimal numbers. That is to add the 1650trailing digits first and propagate the resulting carry upwards. Since this is a lower level algorithm the name will have a ``s\_'' prefix. 1651Historically that convention stems from the MPI library where ``s\_'' stood for static functions that were hidden from the developer entirely. 1652 1653\newpage 1654\begin{figure}[!here] 1655\begin{center} 1656\begin{small} 1657\begin{tabular}{l} 1658\hline Algorithm \textbf{s\_mp\_add}. \\ 1659\textbf{Input}. Two mp\_ints $a$ and $b$ \\ 1660\textbf{Output}. The unsigned addition $c = \vert a \vert + \vert b \vert$. \\ 1661\hline \\ 16621. if $a.used > b.used$ then \\ 1663\hspace{+3mm}1.1 $min \leftarrow b.used$ \\ 1664\hspace{+3mm}1.2 $max \leftarrow a.used$ \\ 1665\hspace{+3mm}1.3 $x \leftarrow a$ \\ 16662. else \\ 1667\hspace{+3mm}2.1 $min \leftarrow a.used$ \\ 1668\hspace{+3mm}2.2 $max \leftarrow b.used$ \\ 1669\hspace{+3mm}2.3 $x \leftarrow b$ \\ 16703. If $c.alloc < max + 1$ then grow $c$ to hold at least $max + 1$ digits (\textit{mp\_grow}) \\ 16714. $oldused \leftarrow c.used$ \\ 16725. $c.used \leftarrow max + 1$ \\ 16736. $u \leftarrow 0$ \\ 16747. for $n$ from $0$ to $min - 1$ do \\ 1675\hspace{+3mm}7.1 $c_n \leftarrow a_n + b_n + u$ \\ 1676\hspace{+3mm}7.2 $u \leftarrow c_n >> lg(\beta)$ \\ 1677\hspace{+3mm}7.3 $c_n \leftarrow c_n \mbox{ (mod }\beta\mbox{)}$ \\ 16788. if $min \ne max$ then do \\ 1679\hspace{+3mm}8.1 for $n$ from $min$ to $max - 1$ do \\ 1680\hspace{+6mm}8.1.1 $c_n \leftarrow x_n + u$ \\ 1681\hspace{+6mm}8.1.2 $u \leftarrow c_n >> lg(\beta)$ \\ 1682\hspace{+6mm}8.1.3 $c_n \leftarrow c_n \mbox{ (mod }\beta\mbox{)}$ \\ 16839. $c_{max} \leftarrow u$ \\ 168410. if $olduse > max$ then \\ 1685\hspace{+3mm}10.1 for $n$ from $max + 1$ to $oldused - 1$ do \\ 1686\hspace{+6mm}10.1.1 $c_n \leftarrow 0$ \\ 168711. Clamp excess digits in $c$. (\textit{mp\_clamp}) \\ 168812. Return(\textit{MP\_OKAY}) \\ 1689\hline 1690\end{tabular} 1691\end{small} 1692\end{center} 1693\caption{Algorithm s\_mp\_add} 1694\end{figure} 1695 1696\textbf{Algorithm s\_mp\_add.} 1697This algorithm is loosely based on algorithm 14.7 of HAC \cite[pp. 594]{HAC} but has been extended to allow the inputs to have different magnitudes. 1698Coincidentally the description of algorithm A in Knuth \cite[pp. 266]{TAOCPV2} shares the same deficiency as the algorithm from \cite{HAC}. Even the 1699MIX pseudo machine code presented by Knuth \cite[pp. 266-267]{TAOCPV2} is incapable of handling inputs which are of different magnitudes. 1700 1701The first thing that has to be accomplished is to sort out which of the two inputs is the largest. The addition logic 1702will simply add all of the smallest input to the largest input and store that first part of the result in the 1703destination. Then it will apply a simpler addition loop to excess digits of the larger input. 1704 1705The first two steps will handle sorting the inputs such that $min$ and $max$ hold the digit counts of the two 1706inputs. The variable $x$ will be an mp\_int alias for the largest input or the second input $b$ if they have the 1707same number of digits. After the inputs are sorted the destination $c$ is grown as required to accomodate the sum 1708of the two inputs. The original \textbf{used} count of $c$ is copied and set to the new used count. 1709 1710At this point the first addition loop will go through as many digit positions that both inputs have. The carry 1711variable $\mu$ is set to zero outside the loop. Inside the loop an ``addition'' step requires three statements to produce 1712one digit of the summand. First 1713two digits from $a$ and $b$ are added together along with the carry $\mu$. The carry of this step is extracted and stored 1714in $\mu$ and finally the digit of the result $c_n$ is truncated within the range $0 \le c_n < \beta$. 1715 1716Now all of the digit positions that both inputs have in common have been exhausted. If $min \ne max$ then $x$ is an alias 1717for one of the inputs that has more digits. A simplified addition loop is then used to essentially copy the remaining digits 1718and the carry to the destination. 1719 1720The final carry is stored in $c_{max}$ and digits above $max$ upto $oldused$ are zeroed which completes the addition. 1721 1722 1723\vspace{+3mm}\begin{small} 1724\hspace{-5.1mm}{\bf File}: bn\_s\_mp\_add.c 1725\vspace{-3mm} 1726\begin{alltt} 1727\end{alltt} 1728\end{small} 1729 1730We first sort (lines 28 to 36) the inputs based on magnitude and determine the $min$ and $max$ variables. 1731Note that $x$ is a pointer to an mp\_int assigned to the largest input, in effect it is a local alias. Next we 1732grow the destination (38 to 42) ensure that it can accomodate the result of the addition. 1733 1734Similar to the implementation of mp\_copy this function uses the braced code and local aliases coding style. The three aliases that are on 1735lines 56, 59 and 62 represent the two inputs and destination variables respectively. These aliases are used to ensure the 1736compiler does not have to dereference $a$, $b$ or $c$ (respectively) to access the digits of the respective mp\_int. 1737 1738The initial carry $u$ will be cleared (line 65), note that $u$ is of type mp\_digit which ensures type 1739compatibility within the implementation. The initial addition (line 66 to 75) adds digits from 1740both inputs until the smallest input runs out of digits. Similarly the conditional addition loop 1741(line 81 to 90) adds the remaining digits from the larger of the two inputs. The addition is finished 1742with the final carry being stored in $tmpc$ (line 94). Note the ``++'' operator within the same expression. 1743After line 94, $tmpc$ will point to the $c.used$'th digit of the mp\_int $c$. This is useful 1744for the next loop (line 97 to 99) which set any old upper digits to zero. 1745 1746\subsection{Low Level Subtraction} 1747The low level unsigned subtraction algorithm is very similar to the low level unsigned addition algorithm. The principle difference is that the 1748unsigned subtraction algorithm requires the result to be positive. That is when computing $a - b$ the condition $\vert a \vert \ge \vert b\vert$ must 1749be met for this algorithm to function properly. Keep in mind this low level algorithm is not meant to be used in higher level algorithms directly. 1750This algorithm as will be shown can be used to create functional signed addition and subtraction algorithms. 1751 1752 1753For this algorithm a new variable is required to make the description simpler. Recall from section 1.3.1 that a mp\_digit must be able to represent 1754the range $0 \le x < 2\beta$ for the algorithms to work correctly. However, it is allowable that a mp\_digit represent a larger range of values. For 1755this algorithm we will assume that the variable $\gamma$ represents the number of bits available in a 1756mp\_digit (\textit{this implies $2^{\gamma} > \beta$}). 1757 1758For example, the default for LibTomMath is to use a ``unsigned long'' for the mp\_digit ``type'' while $\beta = 2^{28}$. In ISO C an ``unsigned long'' 1759data type must be able to represent $0 \le x < 2^{32}$ meaning that in this case $\gamma \ge 32$. 1760 1761\newpage\begin{figure}[!here] 1762\begin{center} 1763\begin{small} 1764\begin{tabular}{l} 1765\hline Algorithm \textbf{s\_mp\_sub}. \\ 1766\textbf{Input}. Two mp\_ints $a$ and $b$ ($\vert a \vert \ge \vert b \vert$) \\ 1767\textbf{Output}. The unsigned subtraction $c = \vert a \vert - \vert b \vert$. \\ 1768\hline \\ 17691. $min \leftarrow b.used$ \\ 17702. $max \leftarrow a.used$ \\ 17713. If $c.alloc < max$ then grow $c$ to hold at least $max$ digits. (\textit{mp\_grow}) \\ 17724. $oldused \leftarrow c.used$ \\ 17735. $c.used \leftarrow max$ \\ 17746. $u \leftarrow 0$ \\ 17757. for $n$ from $0$ to $min - 1$ do \\ 1776\hspace{3mm}7.1 $c_n \leftarrow a_n - b_n - u$ \\ 1777\hspace{3mm}7.2 $u \leftarrow c_n >> (\gamma - 1)$ \\ 1778\hspace{3mm}7.3 $c_n \leftarrow c_n \mbox{ (mod }\beta\mbox{)}$ \\ 17798. if $min < max$ then do \\ 1780\hspace{3mm}8.1 for $n$ from $min$ to $max - 1$ do \\ 1781\hspace{6mm}8.1.1 $c_n \leftarrow a_n - u$ \\ 1782\hspace{6mm}8.1.2 $u \leftarrow c_n >> (\gamma - 1)$ \\ 1783\hspace{6mm}8.1.3 $c_n \leftarrow c_n \mbox{ (mod }\beta\mbox{)}$ \\ 17849. if $oldused > max$ then do \\ 1785\hspace{3mm}9.1 for $n$ from $max$ to $oldused - 1$ do \\ 1786\hspace{6mm}9.1.1 $c_n \leftarrow 0$ \\ 178710. Clamp excess digits of $c$. (\textit{mp\_clamp}). \\ 178811. Return(\textit{MP\_OKAY}). \\ 1789\hline 1790\end{tabular} 1791\end{small} 1792\end{center} 1793\caption{Algorithm s\_mp\_sub} 1794\end{figure} 1795 1796\textbf{Algorithm s\_mp\_sub.} 1797This algorithm performs the unsigned subtraction of two mp\_int variables under the restriction that the result must be positive. That is when 1798passing variables $a$ and $b$ the condition that $\vert a \vert \ge \vert b \vert$ must be met for the algorithm to function correctly. This 1799algorithm is loosely based on algorithm 14.9 \cite[pp. 595]{HAC} and is similar to algorithm S in \cite[pp. 267]{TAOCPV2} as well. As was the case 1800of the algorithm s\_mp\_add both other references lack discussion concerning various practical details such as when the inputs differ in magnitude. 1801 1802The initial sorting of the inputs is trivial in this algorithm since $a$ is guaranteed to have at least the same magnitude of $b$. Steps 1 and 2 1803set the $min$ and $max$ variables. Unlike the addition routine there is guaranteed to be no carry which means that the final result can be at 1804most $max$ digits in length as opposed to $max + 1$. Similar to the addition algorithm the \textbf{used} count of $c$ is copied locally and 1805set to the maximal count for the operation. 1806 1807The subtraction loop that begins on step seven is essentially the same as the addition loop of algorithm s\_mp\_add except single precision 1808subtraction is used instead. Note the use of the $\gamma$ variable to extract the carry (\textit{also known as the borrow}) within the subtraction 1809loops. Under the assumption that two's complement single precision arithmetic is used this will successfully extract the desired carry. 1810 1811For example, consider subtracting $0101_2$ from $0100_2$ where $\gamma = 4$ and $\beta = 2$. The least significant bit will force a carry upwards to 1812the third bit which will be set to zero after the borrow. After the very first bit has been subtracted $4 - 1 \equiv 0011_2$ will remain, When the 1813third bit of $0101_2$ is subtracted from the result it will cause another carry. In this case though the carry will be forced to propagate all the 1814way to the most significant bit. 1815 1816Recall that $\beta < 2^{\gamma}$. This means that if a carry does occur just before the $lg(\beta)$'th bit it will propagate all the way to the most 1817significant bit. Thus, the high order bits of the mp\_digit that are not part of the actual digit will either be all zero, or all one. All that 1818is needed is a single zero or one bit for the carry. Therefore a single logical shift right by $\gamma - 1$ positions is sufficient to extract the 1819carry. This method of carry extraction may seem awkward but the reason for it becomes apparent when the implementation is discussed. 1820 1821If $b$ has a smaller magnitude than $a$ then step 9 will force the carry and copy operation to propagate through the larger input $a$ into $c$. Step 182210 will ensure that any leading digits of $c$ above the $max$'th position are zeroed. 1823 1824\vspace{+3mm}\begin{small} 1825\hspace{-5.1mm}{\bf File}: bn\_s\_mp\_sub.c 1826\vspace{-3mm} 1827\begin{alltt} 1828\end{alltt} 1829\end{small} 1830 1831Like low level addition we ``sort'' the inputs. Except in this case the sorting is hardcoded 1832(lines 25 and 26). In reality the $min$ and $max$ variables are only aliases and are only 1833used to make the source code easier to read. Again the pointer alias optimization is used 1834within this algorithm. The aliases $tmpa$, $tmpb$ and $tmpc$ are initialized 1835(lines 42, 43 and 44) for $a$, $b$ and $c$ respectively. 1836 1837The first subtraction loop (lines 47 through 61) subtract digits from both inputs until the smaller of 1838the two inputs has been exhausted. As remarked earlier there is an implementation reason for using the ``awkward'' 1839method of extracting the carry (line 57). The traditional method for extracting the carry would be to shift 1840by $lg(\beta)$ positions and logically AND the least significant bit. The AND operation is required because all of 1841the bits above the $\lg(\beta)$'th bit will be set to one after a carry occurs from subtraction. This carry 1842extraction requires two relatively cheap operations to extract the carry. The other method is to simply shift the 1843most significant bit to the least significant bit thus extracting the carry with a single cheap operation. This 1844optimization only works on twos compliment machines which is a safe assumption to make. 1845 1846If $a$ has a larger magnitude than $b$ an additional loop (lines 64 through 73) is required to propagate 1847the carry through $a$ and copy the result to $c$. 1848 1849\subsection{High Level Addition} 1850Now that both lower level addition and subtraction algorithms have been established an effective high level signed addition algorithm can be 1851established. This high level addition algorithm will be what other algorithms and developers will use to perform addition of mp\_int data 1852types. 1853 1854Recall from section 5.2 that an mp\_int represents an integer with an unsigned mantissa (\textit{the array of digits}) and a \textbf{sign} 1855flag. A high level addition is actually performed as a series of eight separate cases which can be optimized down to three unique cases. 1856 1857\begin{figure}[!here] 1858\begin{center} 1859\begin{tabular}{l} 1860\hline Algorithm \textbf{mp\_add}. \\ 1861\textbf{Input}. Two mp\_ints $a$ and $b$ \\ 1862\textbf{Output}. The signed addition $c = a + b$. \\ 1863\hline \\ 18641. if $a.sign = b.sign$ then do \\ 1865\hspace{3mm}1.1 $c.sign \leftarrow a.sign$ \\ 1866\hspace{3mm}1.2 $c \leftarrow \vert a \vert + \vert b \vert$ (\textit{s\_mp\_add})\\ 18672. else do \\ 1868\hspace{3mm}2.1 if $\vert a \vert < \vert b \vert$ then do (\textit{mp\_cmp\_mag}) \\ 1869\hspace{6mm}2.1.1 $c.sign \leftarrow b.sign$ \\ 1870\hspace{6mm}2.1.2 $c \leftarrow \vert b \vert - \vert a \vert$ (\textit{s\_mp\_sub}) \\ 1871\hspace{3mm}2.2 else do \\ 1872\hspace{6mm}2.2.1 $c.sign \leftarrow a.sign$ \\ 1873\hspace{6mm}2.2.2 $c \leftarrow \vert a \vert - \vert b \vert$ \\ 18743. Return(\textit{MP\_OKAY}). \\ 1875\hline 1876\end{tabular} 1877\end{center} 1878\caption{Algorithm mp\_add} 1879\end{figure} 1880 1881\textbf{Algorithm mp\_add.} 1882This algorithm performs the signed addition of two mp\_int variables. There is no reference algorithm to draw upon from 1883either \cite{TAOCPV2} or \cite{HAC} since they both only provide unsigned operations. The algorithm is fairly 1884straightforward but restricted since subtraction can only produce positive results. 1885 1886\begin{figure}[here] 1887\begin{small} 1888\begin{center} 1889\begin{tabular}{|c|c|c|c|c|} 1890\hline \textbf{Sign of $a$} & \textbf{Sign of $b$} & \textbf{$\vert a \vert > \vert b \vert $} & \textbf{Unsigned Operation} & \textbf{Result Sign Flag} \\ 1891\hline $+$ & $+$ & Yes & $c = a + b$ & $a.sign$ \\ 1892\hline $+$ & $+$ & No & $c = a + b$ & $a.sign$ \\ 1893\hline $-$ & $-$ & Yes & $c = a + b$ & $a.sign$ \\ 1894\hline $-$ & $-$ & No & $c = a + b$ & $a.sign$ \\ 1895\hline &&&&\\ 1896 1897\hline $+$ & $-$ & No & $c = b - a$ & $b.sign$ \\ 1898\hline $-$ & $+$ & No & $c = b - a$ & $b.sign$ \\ 1899 1900\hline &&&&\\ 1901 1902\hline $+$ & $-$ & Yes & $c = a - b$ & $a.sign$ \\ 1903\hline $-$ & $+$ & Yes & $c = a - b$ & $a.sign$ \\ 1904 1905\hline 1906\end{tabular} 1907\end{center} 1908\end{small} 1909\caption{Addition Guide Chart} 1910\label{fig:AddChart} 1911\end{figure} 1912 1913Figure~\ref{fig:AddChart} lists all of the eight possible input combinations and is sorted to show that only three 1914specific cases need to be handled. The return code of the unsigned operations at step 1.2, 2.1.2 and 2.2.2 are 1915forwarded to step three to check for errors. This simplifies the description of the algorithm considerably and best 1916follows how the implementation actually was achieved. 1917 1918Also note how the \textbf{sign} is set before the unsigned addition or subtraction is performed. Recall from the descriptions of algorithms 1919s\_mp\_add and s\_mp\_sub that the mp\_clamp function is used at the end to trim excess digits. The mp\_clamp algorithm will set the \textbf{sign} 1920to \textbf{MP\_ZPOS} when the \textbf{used} digit count reaches zero. 1921 1922For example, consider performing $-a + a$ with algorithm mp\_add. By the description of the algorithm the sign is set to \textbf{MP\_NEG} which would 1923produce a result of $-0$. However, since the sign is set first then the unsigned addition is performed the subsequent usage of algorithm mp\_clamp 1924within algorithm s\_mp\_add will force $-0$ to become $0$. 1925 1926\vspace{+3mm}\begin{small} 1927\hspace{-5.1mm}{\bf File}: bn\_mp\_add.c 1928\vspace{-3mm} 1929\begin{alltt} 1930\end{alltt} 1931\end{small} 1932 1933The source code follows the algorithm fairly closely. The most notable new source code addition is the usage of the $res$ integer variable which 1934is used to pass result of the unsigned operations forward. Unlike in the algorithm, the variable $res$ is merely returned as is without 1935explicitly checking it and returning the constant \textbf{MP\_OKAY}. The observation is this algorithm will succeed or fail only if the lower 1936level functions do so. Returning their return code is sufficient. 1937 1938\subsection{High Level Subtraction} 1939The high level signed subtraction algorithm is essentially the same as the high level signed addition algorithm. 1940 1941\newpage\begin{figure}[!here] 1942\begin{center} 1943\begin{tabular}{l} 1944\hline Algorithm \textbf{mp\_sub}. \\ 1945\textbf{Input}. Two mp\_ints $a$ and $b$ \\ 1946\textbf{Output}. The signed subtraction $c = a - b$. \\ 1947\hline \\ 19481. if $a.sign \ne b.sign$ then do \\ 1949\hspace{3mm}1.1 $c.sign \leftarrow a.sign$ \\ 1950\hspace{3mm}1.2 $c \leftarrow \vert a \vert + \vert b \vert$ (\textit{s\_mp\_add}) \\ 19512. else do \\ 1952\hspace{3mm}2.1 if $\vert a \vert \ge \vert b \vert$ then do (\textit{mp\_cmp\_mag}) \\ 1953\hspace{6mm}2.1.1 $c.sign \leftarrow a.sign$ \\ 1954\hspace{6mm}2.1.2 $c \leftarrow \vert a \vert - \vert b \vert$ (\textit{s\_mp\_sub}) \\ 1955\hspace{3mm}2.2 else do \\ 1956\hspace{6mm}2.2.1 $c.sign \leftarrow \left \lbrace \begin{array}{ll} 1957 MP\_ZPOS & \mbox{if }a.sign = MP\_NEG \\ 1958 MP\_NEG & \mbox{otherwise} \\ 1959 \end{array} \right .$ \\ 1960\hspace{6mm}2.2.2 $c \leftarrow \vert b \vert - \vert a \vert$ \\ 19613. Return(\textit{MP\_OKAY}). \\ 1962\hline 1963\end{tabular} 1964\end{center} 1965\caption{Algorithm mp\_sub} 1966\end{figure} 1967 1968\textbf{Algorithm mp\_sub.} 1969This algorithm performs the signed subtraction of two inputs. Similar to algorithm mp\_add there is no reference in either \cite{TAOCPV2} or 1970\cite{HAC}. Also this algorithm is restricted by algorithm s\_mp\_sub. Chart \ref{fig:SubChart} lists the eight possible inputs and 1971the operations required. 1972 1973\begin{figure}[!here] 1974\begin{small} 1975\begin{center} 1976\begin{tabular}{|c|c|c|c|c|} 1977\hline \textbf{Sign of $a$} & \textbf{Sign of $b$} & \textbf{$\vert a \vert \ge \vert b \vert $} & \textbf{Unsigned Operation} & \textbf{Result Sign Flag} \\ 1978\hline $+$ & $-$ & Yes & $c = a + b$ & $a.sign$ \\ 1979\hline $+$ & $-$ & No & $c = a + b$ & $a.sign$ \\ 1980\hline $-$ & $+$ & Yes & $c = a + b$ & $a.sign$ \\ 1981\hline $-$ & $+$ & No & $c = a + b$ & $a.sign$ \\ 1982\hline &&&& \\ 1983\hline $+$ & $+$ & Yes & $c = a - b$ & $a.sign$ \\ 1984\hline $-$ & $-$ & Yes & $c = a - b$ & $a.sign$ \\ 1985\hline &&&& \\ 1986\hline $+$ & $+$ & No & $c = b - a$ & $\mbox{opposite of }a.sign$ \\ 1987\hline $-$ & $-$ & No & $c = b - a$ & $\mbox{opposite of }a.sign$ \\ 1988\hline 1989\end{tabular} 1990\end{center} 1991\end{small} 1992\caption{Subtraction Guide Chart} 1993\label{fig:SubChart} 1994\end{figure} 1995 1996Similar to the case of algorithm mp\_add the \textbf{sign} is set first before the unsigned addition or subtraction. That is to prevent the 1997algorithm from producing $-a - -a = -0$ as a result. 1998 1999\vspace{+3mm}\begin{small} 2000\hspace{-5.1mm}{\bf File}: bn\_mp\_sub.c 2001\vspace{-3mm} 2002\begin{alltt} 2003\end{alltt} 2004\end{small} 2005 2006Much like the implementation of algorithm mp\_add the variable $res$ is used to catch the return code of the unsigned addition or subtraction operations 2007and forward it to the end of the function. On line 39 the ``not equal to'' \textbf{MP\_LT} expression is used to emulate a 2008``greater than or equal to'' comparison. 2009 2010\section{Bit and Digit Shifting} 2011It is quite common to think of a multiple precision integer as a polynomial in $x$, that is $y = f(\beta)$ where $f(x) = \sum_{i=0}^{n-1} a_i x^i$. 2012This notation arises within discussion of Montgomery and Diminished Radix Reduction as well as Karatsuba multiplication and squaring. 2013 2014In order to facilitate operations on polynomials in $x$ as above a series of simple ``digit'' algorithms have to be established. That is to shift 2015the digits left or right as well to shift individual bits of the digits left and right. It is important to note that not all ``shift'' operations 2016are on radix-$\beta$ digits. 2017 2018\subsection{Multiplication by Two} 2019 2020In a binary system where the radix is a power of two multiplication by two not only arises often in other algorithms it is a fairly efficient 2021operation to perform. A single precision logical shift left is sufficient to multiply a single digit by two. 2022 2023\newpage\begin{figure}[!here] 2024\begin{small} 2025\begin{center} 2026\begin{tabular}{l} 2027\hline Algorithm \textbf{mp\_mul\_2}. \\ 2028\textbf{Input}. One mp\_int $a$ \\ 2029\textbf{Output}. $b = 2a$. \\ 2030\hline \\ 20311. If $b.alloc < a.used + 1$ then grow $b$ to hold $a.used + 1$ digits. (\textit{mp\_grow}) \\ 20322. $oldused \leftarrow b.used$ \\ 20333. $b.used \leftarrow a.used$ \\ 20344. $r \leftarrow 0$ \\ 20355. for $n$ from 0 to $a.used - 1$ do \\ 2036\hspace{3mm}5.1 $rr \leftarrow a_n >> (lg(\beta) - 1)$ \\ 2037\hspace{3mm}5.2 $b_n \leftarrow (a_n << 1) + r \mbox{ (mod }\beta\mbox{)}$ \\ 2038\hspace{3mm}5.3 $r \leftarrow rr$ \\ 20396. If $r \ne 0$ then do \\ 2040\hspace{3mm}6.1 $b_{n + 1} \leftarrow r$ \\ 2041\hspace{3mm}6.2 $b.used \leftarrow b.used + 1$ \\ 20427. If $b.used < oldused - 1$ then do \\ 2043\hspace{3mm}7.1 for $n$ from $b.used$ to $oldused - 1$ do \\ 2044\hspace{6mm}7.1.1 $b_n \leftarrow 0$ \\ 20458. $b.sign \leftarrow a.sign$ \\ 20469. Return(\textit{MP\_OKAY}).\\ 2047\hline 2048\end{tabular} 2049\end{center} 2050\end{small} 2051\caption{Algorithm mp\_mul\_2} 2052\end{figure} 2053 2054\textbf{Algorithm mp\_mul\_2.} 2055This algorithm will quickly multiply a mp\_int by two provided $\beta$ is a power of two. Neither \cite{TAOCPV2} nor \cite{HAC} describe such 2056an algorithm despite the fact it arises often in other algorithms. The algorithm is setup much like the lower level algorithm s\_mp\_add since 2057it is for all intents and purposes equivalent to the operation $b = \vert a \vert + \vert a \vert$. 2058 2059Step 1 and 2 grow the input as required to accomodate the maximum number of \textbf{used} digits in the result. The initial \textbf{used} count 2060is set to $a.used$ at step 4. Only if there is a final carry will the \textbf{used} count require adjustment. 2061 2062Step 6 is an optimization implementation of the addition loop for this specific case. That is since the two values being added together 2063are the same there is no need to perform two reads from the digits of $a$. Step 6.1 performs a single precision shift on the current digit $a_n$ to 2064obtain what will be the carry for the next iteration. Step 6.2 calculates the $n$'th digit of the result as single precision shift of $a_n$ plus 2065the previous carry. Recall from section 4.1 that $a_n << 1$ is equivalent to $a_n \cdot 2$. An iteration of the addition loop is finished with 2066forwarding the carry to the next iteration. 2067 2068Step 7 takes care of any final carry by setting the $a.used$'th digit of the result to the carry and augmenting the \textbf{used} count of $b$. 2069Step 8 clears any leading digits of $b$ in case it originally had a larger magnitude than $a$. 2070 2071\vspace{+3mm}\begin{small} 2072\hspace{-5.1mm}{\bf File}: bn\_mp\_mul\_2.c 2073\vspace{-3mm} 2074\begin{alltt} 2075\end{alltt} 2076\end{small} 2077 2078This implementation is essentially an optimized implementation of s\_mp\_add for the case of doubling an input. The only noteworthy difference 2079is the use of the logical shift operator on line 52 to perform a single precision doubling. 2080 2081\subsection{Division by Two} 2082A division by two can just as easily be accomplished with a logical shift right as multiplication by two can be with a logical shift left. 2083 2084\newpage\begin{figure}[!here] 2085\begin{small} 2086\begin{center} 2087\begin{tabular}{l} 2088\hline Algorithm \textbf{mp\_div\_2}. \\ 2089\textbf{Input}. One mp\_int $a$ \\ 2090\textbf{Output}. $b = a/2$. \\ 2091\hline \\ 20921. If $b.alloc < a.used$ then grow $b$ to hold $a.used$ digits. (\textit{mp\_grow}) \\ 20932. If the reallocation failed return(\textit{MP\_MEM}). \\ 20943. $oldused \leftarrow b.used$ \\ 20954. $b.used \leftarrow a.used$ \\ 20965. $r \leftarrow 0$ \\ 20976. for $n$ from $b.used - 1$ to $0$ do \\ 2098\hspace{3mm}6.1 $rr \leftarrow a_n \mbox{ (mod }2\mbox{)}$\\ 2099\hspace{3mm}6.2 $b_n \leftarrow (a_n >> 1) + (r << (lg(\beta) - 1)) \mbox{ (mod }\beta\mbox{)}$ \\ 2100\hspace{3mm}6.3 $r \leftarrow rr$ \\ 21017. If $b.used < oldused - 1$ then do \\ 2102\hspace{3mm}7.1 for $n$ from $b.used$ to $oldused - 1$ do \\ 2103\hspace{6mm}7.1.1 $b_n \leftarrow 0$ \\ 21048. $b.sign \leftarrow a.sign$ \\ 21059. Clamp excess digits of $b$. (\textit{mp\_clamp}) \\ 210610. Return(\textit{MP\_OKAY}).\\ 2107\hline 2108\end{tabular} 2109\end{center} 2110\end{small} 2111\caption{Algorithm mp\_div\_2} 2112\end{figure} 2113 2114\textbf{Algorithm mp\_div\_2.} 2115This algorithm will divide an mp\_int by two using logical shifts to the right. Like mp\_mul\_2 it uses a modified low level addition 2116core as the basis of the algorithm. Unlike mp\_mul\_2 the shift operations work from the leading digit to the trailing digit. The algorithm 2117could be written to work from the trailing digit to the leading digit however, it would have to stop one short of $a.used - 1$ digits to prevent 2118reading past the end of the array of digits. 2119 2120Essentially the loop at step 6 is similar to that of mp\_mul\_2 except the logical shifts go in the opposite direction and the carry is at the 2121least significant bit not the most significant bit. 2122 2123\vspace{+3mm}\begin{small} 2124\hspace{-5.1mm}{\bf File}: bn\_mp\_div\_2.c 2125\vspace{-3mm} 2126\begin{alltt} 2127\end{alltt} 2128\end{small} 2129 2130\section{Polynomial Basis Operations} 2131Recall from section 4.3 that any integer can be represented as a polynomial in $x$ as $y = f(\beta)$. Such a representation is also known as 2132the polynomial basis \cite[pp. 48]{ROSE}. Given such a notation a multiplication or division by $x$ amounts to shifting whole digits a single 2133place. The need for such operations arises in several other higher level algorithms such as Barrett and Montgomery reduction, integer 2134division and Karatsuba multiplication. 2135 2136Converting from an array of digits to polynomial basis is very simple. Consider the integer $y \equiv (a_2, a_1, a_0)_{\beta}$ and recall that 2137$y = \sum_{i=0}^{2} a_i \beta^i$. Simply replace $\beta$ with $x$ and the expression is in polynomial basis. For example, $f(x) = 8x + 9$ is the 2138polynomial basis representation for $89$ using radix ten. That is, $f(10) = 8(10) + 9 = 89$. 2139 2140\subsection{Multiplication by $x$} 2141 2142Given a polynomial in $x$ such as $f(x) = a_n x^n + a_{n-1} x^{n-1} + ... + a_0$ multiplying by $x$ amounts to shifting the coefficients up one 2143degree. In this case $f(x) \cdot x = a_n x^{n+1} + a_{n-1} x^n + ... + a_0 x$. From a scalar basis point of view multiplying by $x$ is equivalent to 2144multiplying by the integer $\beta$. 2145 2146\newpage\begin{figure}[!here] 2147\begin{small} 2148\begin{center} 2149\begin{tabular}{l} 2150\hline Algorithm \textbf{mp\_lshd}. \\ 2151\textbf{Input}. One mp\_int $a$ and an integer $b$ \\ 2152\textbf{Output}. $a \leftarrow a \cdot \beta^b$ (equivalent to multiplication by $x^b$). \\ 2153\hline \\ 21541. If $b \le 0$ then return(\textit{MP\_OKAY}). \\ 21552. If $a.alloc < a.used + b$ then grow $a$ to at least $a.used + b$ digits. (\textit{mp\_grow}). \\ 21563. If the reallocation failed return(\textit{MP\_MEM}). \\ 21574. $a.used \leftarrow a.used + b$ \\ 21585. $i \leftarrow a.used - 1$ \\ 21596. $j \leftarrow a.used - 1 - b$ \\ 21607. for $n$ from $a.used - 1$ to $b$ do \\ 2161\hspace{3mm}7.1 $a_{i} \leftarrow a_{j}$ \\ 2162\hspace{3mm}7.2 $i \leftarrow i - 1$ \\ 2163\hspace{3mm}7.3 $j \leftarrow j - 1$ \\ 21648. for $n$ from 0 to $b - 1$ do \\ 2165\hspace{3mm}8.1 $a_n \leftarrow 0$ \\ 21669. Return(\textit{MP\_OKAY}). \\ 2167\hline 2168\end{tabular} 2169\end{center} 2170\end{small} 2171\caption{Algorithm mp\_lshd} 2172\end{figure} 2173 2174\textbf{Algorithm mp\_lshd.} 2175This algorithm multiplies an mp\_int by the $b$'th power of $x$. This is equivalent to multiplying by $\beta^b$. The algorithm differs 2176from the other algorithms presented so far as it performs the operation in place instead storing the result in a separate location. The 2177motivation behind this change is due to the way this function is typically used. Algorithms such as mp\_add store the result in an optionally 2178different third mp\_int because the original inputs are often still required. Algorithm mp\_lshd (\textit{and similarly algorithm mp\_rshd}) is 2179typically used on values where the original value is no longer required. The algorithm will return success immediately if 2180$b \le 0$ since the rest of algorithm is only valid when $b > 0$. 2181 2182First the destination $a$ is grown as required to accomodate the result. The counters $i$ and $j$ are used to form a \textit{sliding window} over 2183the digits of $a$ of length $b$. The head of the sliding window is at $i$ (\textit{the leading digit}) and the tail at $j$ (\textit{the trailing digit}). 2184The loop on step 7 copies the digit from the tail to the head. In each iteration the window is moved down one digit. The last loop on 2185step 8 sets the lower $b$ digits to zero. 2186 2187\newpage 2188\begin{center} 2189\begin{figure}[here] 2190\includegraphics{pics/sliding_window.ps} 2191\caption{Sliding Window Movement} 2192\label{pic:sliding_window} 2193\end{figure} 2194\end{center} 2195 2196\vspace{+3mm}\begin{small} 2197\hspace{-5.1mm}{\bf File}: bn\_mp\_lshd.c 2198\vspace{-3mm} 2199\begin{alltt} 2200\end{alltt} 2201\end{small} 2202 2203The if statement (line 24) ensures that the $b$ variable is greater than zero since we do not interpret negative 2204shift counts properly. The \textbf{used} count is incremented by $b$ before the copy loop begins. This elminates 2205the need for an additional variable in the for loop. The variable $top$ (line 42) is an alias 2206for the leading digit while $bottom$ (line 45) is an alias for the trailing edge. The aliases form a 2207window of exactly $b$ digits over the input. 2208 2209\subsection{Division by $x$} 2210 2211Division by powers of $x$ is easily achieved by shifting the digits right and removing any that will end up to the right of the zero'th digit. 2212 2213\newpage\begin{figure}[!here] 2214\begin{small} 2215\begin{center} 2216\begin{tabular}{l} 2217\hline Algorithm \textbf{mp\_rshd}. \\ 2218\textbf{Input}. One mp\_int $a$ and an integer $b$ \\ 2219\textbf{Output}. $a \leftarrow a / \beta^b$ (Divide by $x^b$). \\ 2220\hline \\ 22211. If $b \le 0$ then return. \\ 22222. If $a.used \le b$ then do \\ 2223\hspace{3mm}2.1 Zero $a$. (\textit{mp\_zero}). \\ 2224\hspace{3mm}2.2 Return. \\ 22253. $i \leftarrow 0$ \\ 22264. $j \leftarrow b$ \\ 22275. for $n$ from 0 to $a.used - b - 1$ do \\ 2228\hspace{3mm}5.1 $a_i \leftarrow a_j$ \\ 2229\hspace{3mm}5.2 $i \leftarrow i + 1$ \\ 2230\hspace{3mm}5.3 $j \leftarrow j + 1$ \\ 22316. for $n$ from $a.used - b$ to $a.used - 1$ do \\ 2232\hspace{3mm}6.1 $a_n \leftarrow 0$ \\ 22337. $a.used \leftarrow a.used - b$ \\ 22348. Return. \\ 2235\hline 2236\end{tabular} 2237\end{center} 2238\end{small} 2239\caption{Algorithm mp\_rshd} 2240\end{figure} 2241 2242\textbf{Algorithm mp\_rshd.} 2243This algorithm divides the input in place by the $b$'th power of $x$. It is analogous to dividing by a $\beta^b$ but much quicker since 2244it does not require single precision division. This algorithm does not actually return an error code as it cannot fail. 2245 2246If the input $b$ is less than one the algorithm quickly returns without performing any work. If the \textbf{used} count is less than or equal 2247to the shift count $b$ then it will simply zero the input and return. 2248 2249After the trivial cases of inputs have been handled the sliding window is setup. Much like the case of algorithm mp\_lshd a sliding window that 2250is $b$ digits wide is used to copy the digits. Unlike mp\_lshd the window slides in the opposite direction from the trailing to the leading digit. 2251Also the digits are copied from the leading to the trailing edge. 2252 2253Once the window copy is complete the upper digits must be zeroed and the \textbf{used} count decremented. 2254 2255\vspace{+3mm}\begin{small} 2256\hspace{-5.1mm}{\bf File}: bn\_mp\_rshd.c 2257\vspace{-3mm} 2258\begin{alltt} 2259\end{alltt} 2260\end{small} 2261 2262The only noteworthy element of this routine is the lack of a return type since it cannot fail. Like mp\_lshd() we 2263form a sliding window except we copy in the other direction. After the window (line 60) we then zero 2264the upper digits of the input to make sure the result is correct. 2265 2266\section{Powers of Two} 2267 2268Now that algorithms for moving single bits as well as whole digits exist algorithms for moving the ``in between'' distances are required. For 2269example, to quickly multiply by $2^k$ for any $k$ without using a full multiplier algorithm would prove useful. Instead of performing single 2270shifts $k$ times to achieve a multiplication by $2^{\pm k}$ a mixture of whole digit shifting and partial digit shifting is employed. 2271 2272\subsection{Multiplication by Power of Two} 2273 2274\newpage\begin{figure}[!here] 2275\begin{small} 2276\begin{center} 2277\begin{tabular}{l} 2278\hline Algorithm \textbf{mp\_mul\_2d}. \\ 2279\textbf{Input}. One mp\_int $a$ and an integer $b$ \\ 2280\textbf{Output}. $c \leftarrow a \cdot 2^b$. \\ 2281\hline \\ 22821. $c \leftarrow a$. (\textit{mp\_copy}) \\ 22832. If $c.alloc < c.used + \lfloor b / lg(\beta) \rfloor + 2$ then grow $c$ accordingly. \\ 22843. If the reallocation failed return(\textit{MP\_MEM}). \\ 22854. If $b \ge lg(\beta)$ then \\ 2286\hspace{3mm}4.1 $c \leftarrow c \cdot \beta^{\lfloor b / lg(\beta) \rfloor}$ (\textit{mp\_lshd}). \\ 2287\hspace{3mm}4.2 If step 4.1 failed return(\textit{MP\_MEM}). \\ 22885. $d \leftarrow b \mbox{ (mod }lg(\beta)\mbox{)}$ \\ 22896. If $d \ne 0$ then do \\ 2290\hspace{3mm}6.1 $mask \leftarrow 2^d$ \\ 2291\hspace{3mm}6.2 $r \leftarrow 0$ \\ 2292\hspace{3mm}6.3 for $n$ from $0$ to $c.used - 1$ do \\ 2293\hspace{6mm}6.3.1 $rr \leftarrow c_n >> (lg(\beta) - d) \mbox{ (mod }mask\mbox{)}$ \\ 2294\hspace{6mm}6.3.2 $c_n \leftarrow (c_n << d) + r \mbox{ (mod }\beta\mbox{)}$ \\ 2295\hspace{6mm}6.3.3 $r \leftarrow rr$ \\ 2296\hspace{3mm}6.4 If $r > 0$ then do \\ 2297\hspace{6mm}6.4.1 $c_{c.used} \leftarrow r$ \\ 2298\hspace{6mm}6.4.2 $c.used \leftarrow c.used + 1$ \\ 22997. Return(\textit{MP\_OKAY}). \\ 2300\hline 2301\end{tabular} 2302\end{center} 2303\end{small} 2304\caption{Algorithm mp\_mul\_2d} 2305\end{figure} 2306 2307\textbf{Algorithm mp\_mul\_2d.} 2308This algorithm multiplies $a$ by $2^b$ and stores the result in $c$. The algorithm uses algorithm mp\_lshd and a derivative of algorithm mp\_mul\_2 to 2309quickly compute the product. 2310 2311First the algorithm will multiply $a$ by $x^{\lfloor b / lg(\beta) \rfloor}$ which will ensure that the remainder multiplicand is less than 2312$\beta$. For example, if $b = 37$ and $\beta = 2^{28}$ then this step will multiply by $x$ leaving a multiplication by $2^{37 - 28} = 2^{9}$ 2313left. 2314 2315After the digits have been shifted appropriately at most $lg(\beta) - 1$ shifts are left to perform. Step 5 calculates the number of remaining shifts 2316required. If it is non-zero a modified shift loop is used to calculate the remaining product. 2317Essentially the loop is a generic version of algorithm mp\_mul\_2 designed to handle any shift count in the range $1 \le x < lg(\beta)$. The $mask$ 2318variable is used to extract the upper $d$ bits to form the carry for the next iteration. 2319 2320This algorithm is loosely measured as a $O(2n)$ algorithm which means that if the input is $n$-digits that it takes $2n$ ``time'' to 2321complete. It is possible to optimize this algorithm down to a $O(n)$ algorithm at a cost of making the algorithm slightly harder to follow. 2322 2323\vspace{+3mm}\begin{small} 2324\hspace{-5.1mm}{\bf File}: bn\_mp\_mul\_2d.c 2325\vspace{-3mm} 2326\begin{alltt} 2327\end{alltt} 2328\end{small} 2329 2330The shifting is performed in--place which means the first step (line 25) is to copy the input to the 2331destination. We avoid calling mp\_copy() by making sure the mp\_ints are different. The destination then 2332has to be grown (line 32) to accomodate the result. 2333 2334If the shift count $b$ is larger than $lg(\beta)$ then a call to mp\_lshd() is used to handle all of the multiples 2335of $lg(\beta)$. Leaving only a remaining shift of $lg(\beta) - 1$ or fewer bits left. Inside the actual shift 2336loop (lines 46 to 76) we make use of pre--computed values $shift$ and $mask$. These are used to 2337extract the carry bit(s) to pass into the next iteration of the loop. The $r$ and $rr$ variables form a 2338chain between consecutive iterations to propagate the carry. 2339 2340\subsection{Division by Power of Two} 2341 2342\newpage\begin{figure}[!here] 2343\begin{small} 2344\begin{center} 2345\begin{tabular}{l} 2346\hline Algorithm \textbf{mp\_div\_2d}. \\ 2347\textbf{Input}. One mp\_int $a$ and an integer $b$ \\ 2348\textbf{Output}. $c \leftarrow \lfloor a / 2^b \rfloor, d \leftarrow a \mbox{ (mod }2^b\mbox{)}$. \\ 2349\hline \\ 23501. If $b \le 0$ then do \\ 2351\hspace{3mm}1.1 $c \leftarrow a$ (\textit{mp\_copy}) \\ 2352\hspace{3mm}1.2 $d \leftarrow 0$ (\textit{mp\_zero}) \\ 2353\hspace{3mm}1.3 Return(\textit{MP\_OKAY}). \\ 23542. $c \leftarrow a$ \\ 23553. $d \leftarrow a \mbox{ (mod }2^b\mbox{)}$ (\textit{mp\_mod\_2d}) \\ 23564. If $b \ge lg(\beta)$ then do \\ 2357\hspace{3mm}4.1 $c \leftarrow \lfloor c/\beta^{\lfloor b/lg(\beta) \rfloor} \rfloor$ (\textit{mp\_rshd}). \\ 23585. $k \leftarrow b \mbox{ (mod }lg(\beta)\mbox{)}$ \\ 23596. If $k \ne 0$ then do \\ 2360\hspace{3mm}6.1 $mask \leftarrow 2^k$ \\ 2361\hspace{3mm}6.2 $r \leftarrow 0$ \\ 2362\hspace{3mm}6.3 for $n$ from $c.used - 1$ to $0$ do \\ 2363\hspace{6mm}6.3.1 $rr \leftarrow c_n \mbox{ (mod }mask\mbox{)}$ \\ 2364\hspace{6mm}6.3.2 $c_n \leftarrow (c_n >> k) + (r << (lg(\beta) - k))$ \\ 2365\hspace{6mm}6.3.3 $r \leftarrow rr$ \\ 23667. Clamp excess digits of $c$. (\textit{mp\_clamp}) \\ 23678. Return(\textit{MP\_OKAY}). \\ 2368\hline 2369\end{tabular} 2370\end{center} 2371\end{small} 2372\caption{Algorithm mp\_div\_2d} 2373\end{figure} 2374 2375\textbf{Algorithm mp\_div\_2d.} 2376This algorithm will divide an input $a$ by $2^b$ and produce the quotient and remainder. The algorithm is designed much like algorithm 2377mp\_mul\_2d by first using whole digit shifts then single precision shifts. This algorithm will also produce the remainder of the division 2378by using algorithm mp\_mod\_2d. 2379 2380\vspace{+3mm}\begin{small} 2381\hspace{-5.1mm}{\bf File}: bn\_mp\_div\_2d.c 2382\vspace{-3mm} 2383\begin{alltt} 2384\end{alltt} 2385\end{small} 2386 2387The implementation of algorithm mp\_div\_2d is slightly different than the algorithm specifies. The remainder $d$ may be optionally 2388ignored by passing \textbf{NULL} as the pointer to the mp\_int variable. The temporary mp\_int variable $t$ is used to hold the 2389result of the remainder operation until the end. This allows $d$ and $a$ to represent the same mp\_int without modifying $a$ before 2390the quotient is obtained. 2391 2392The remainder of the source code is essentially the same as the source code for mp\_mul\_2d. The only significant difference is 2393the direction of the shifts. 2394 2395\subsection{Remainder of Division by Power of Two} 2396 2397The last algorithm in the series of polynomial basis power of two algorithms is calculating the remainder of division by $2^b$. This 2398algorithm benefits from the fact that in twos complement arithmetic $a \mbox{ (mod }2^b\mbox{)}$ is the same as $a$ AND $2^b - 1$. 2399 2400\begin{figure}[!here] 2401\begin{small} 2402\begin{center} 2403\begin{tabular}{l} 2404\hline Algorithm \textbf{mp\_mod\_2d}. \\ 2405\textbf{Input}. One mp\_int $a$ and an integer $b$ \\ 2406\textbf{Output}. $c \leftarrow a \mbox{ (mod }2^b\mbox{)}$. \\ 2407\hline \\ 24081. If $b \le 0$ then do \\ 2409\hspace{3mm}1.1 $c \leftarrow 0$ (\textit{mp\_zero}) \\ 2410\hspace{3mm}1.2 Return(\textit{MP\_OKAY}). \\ 24112. If $b > a.used \cdot lg(\beta)$ then do \\ 2412\hspace{3mm}2.1 $c \leftarrow a$ (\textit{mp\_copy}) \\ 2413\hspace{3mm}2.2 Return the result of step 2.1. \\ 24143. $c \leftarrow a$ \\ 24154. If step 3 failed return(\textit{MP\_MEM}). \\ 24165. for $n$ from $\lceil b / lg(\beta) \rceil$ to $c.used$ do \\ 2417\hspace{3mm}5.1 $c_n \leftarrow 0$ \\ 24186. $k \leftarrow b \mbox{ (mod }lg(\beta)\mbox{)}$ \\ 24197. $c_{\lfloor b / lg(\beta) \rfloor} \leftarrow c_{\lfloor b / lg(\beta) \rfloor} \mbox{ (mod }2^{k}\mbox{)}$. \\ 24208. Clamp excess digits of $c$. (\textit{mp\_clamp}) \\ 24219. Return(\textit{MP\_OKAY}). \\ 2422\hline 2423\end{tabular} 2424\end{center} 2425\end{small} 2426\caption{Algorithm mp\_mod\_2d} 2427\end{figure} 2428 2429\textbf{Algorithm mp\_mod\_2d.} 2430This algorithm will quickly calculate the value of $a \mbox{ (mod }2^b\mbox{)}$. First if $b$ is less than or equal to zero the 2431result is set to zero. If $b$ is greater than the number of bits in $a$ then it simply copies $a$ to $c$ and returns. Otherwise, $a$ 2432is copied to $b$, leading digits are removed and the remaining leading digit is trimed to the exact bit count. 2433 2434\vspace{+3mm}\begin{small} 2435\hspace{-5.1mm}{\bf File}: bn\_mp\_mod\_2d.c 2436\vspace{-3mm} 2437\begin{alltt} 2438\end{alltt} 2439\end{small} 2440 2441We first avoid cases of $b \le 0$ by simply mp\_zero()'ing the destination in such cases. Next if $2^b$ is larger 2442than the input we just mp\_copy() the input and return right away. After this point we know we must actually 2443perform some work to produce the remainder. 2444 2445Recalling that reducing modulo $2^k$ and a binary ``and'' with $2^k - 1$ are numerically equivalent we can quickly reduce 2446the number. First we zero any digits above the last digit in $2^b$ (line 42). Next we reduce the 2447leading digit of both (line 46) and then mp\_clamp(). 2448 2449\section*{Exercises} 2450\begin{tabular}{cl} 2451$\left [ 3 \right ] $ & Devise an algorithm that performs $a \cdot 2^b$ for generic values of $b$ \\ 2452 & in $O(n)$ time. \\ 2453 &\\ 2454$\left [ 3 \right ] $ & Devise an efficient algorithm to multiply by small low hamming \\ 2455 & weight values such as $3$, $5$ and $9$. Extend it to handle all values \\ 2456 & upto $64$ with a hamming weight less than three. \\ 2457 &\\ 2458$\left [ 2 \right ] $ & Modify the preceding algorithm to handle values of the form \\ 2459 & $2^k - 1$ as well. \\ 2460 &\\ 2461$\left [ 3 \right ] $ & Using only algorithms mp\_mul\_2, mp\_div\_2 and mp\_add create an \\ 2462 & algorithm to multiply two integers in roughly $O(2n^2)$ time for \\ 2463 & any $n$-bit input. Note that the time of addition is ignored in the \\ 2464 & calculation. \\ 2465 & \\ 2466$\left [ 5 \right ] $ & Improve the previous algorithm to have a working time of at most \\ 2467 & $O \left (2^{(k-1)}n + \left ({2n^2 \over k} \right ) \right )$ for an appropriate choice of $k$. Again ignore \\ 2468 & the cost of addition. \\ 2469 & \\ 2470$\left [ 2 \right ] $ & Devise a chart to find optimal values of $k$ for the previous problem \\ 2471 & for $n = 64 \ldots 1024$ in steps of $64$. \\ 2472 & \\ 2473$\left [ 2 \right ] $ & Using only algorithms mp\_abs and mp\_sub devise another method for \\ 2474 & calculating the result of a signed comparison. \\ 2475 & 2476\end{tabular} 2477 2478\chapter{Multiplication and Squaring} 2479\section{The Multipliers} 2480For most number theoretic problems including certain public key cryptographic algorithms, the ``multipliers'' form the most important subset of 2481algorithms of any multiple precision integer package. The set of multiplier algorithms include integer multiplication, squaring and modular reduction 2482where in each of the algorithms single precision multiplication is the dominant operation performed. This chapter will discuss integer multiplication 2483and squaring, leaving modular reductions for the subsequent chapter. 2484 2485The importance of the multiplier algorithms is for the most part driven by the fact that certain popular public key algorithms are based on modular 2486exponentiation, that is computing $d \equiv a^b \mbox{ (mod }c\mbox{)}$ for some arbitrary choice of $a$, $b$, $c$ and $d$. During a modular 2487exponentiation the majority\footnote{Roughly speaking a modular exponentiation will spend about 40\% of the time performing modular reductions, 248835\% of the time performing squaring and 25\% of the time performing multiplications.} of the processor time is spent performing single precision 2489multiplications. 2490 2491For centuries general purpose multiplication has required a lengthly $O(n^2)$ process, whereby each digit of one multiplicand has to be multiplied 2492against every digit of the other multiplicand. Traditional long-hand multiplication is based on this process; while the techniques can differ the 2493overall algorithm used is essentially the same. Only ``recently'' have faster algorithms been studied. First Karatsuba multiplication was discovered in 24941962. This algorithm can multiply two numbers with considerably fewer single precision multiplications when compared to the long-hand approach. 2495This technique led to the discovery of polynomial basis algorithms (\textit{good reference?}) and subquently Fourier Transform based solutions. 2496 2497\section{Multiplication} 2498\subsection{The Baseline Multiplication} 2499\label{sec:basemult} 2500\index{baseline multiplication} 2501Computing the product of two integers in software can be achieved using a trivial adaptation of the standard $O(n^2)$ long-hand multiplication 2502algorithm that school children are taught. The algorithm is considered an $O(n^2)$ algorithm since for two $n$-digit inputs $n^2$ single precision 2503multiplications are required. More specifically for a $m$ and $n$ digit input $m \cdot n$ single precision multiplications are required. To 2504simplify most discussions, it will be assumed that the inputs have comparable number of digits. 2505 2506The ``baseline multiplication'' algorithm is designed to act as the ``catch-all'' algorithm, only to be used when the faster algorithms cannot be 2507used. This algorithm does not use any particularly interesting optimizations and should ideally be avoided if possible. One important 2508facet of this algorithm, is that it has been modified to only produce a certain amount of output digits as resolution. The importance of this 2509modification will become evident during the discussion of Barrett modular reduction. Recall that for a $n$ and $m$ digit input the product 2510will be at most $n + m$ digits. Therefore, this algorithm can be reduced to a full multiplier by having it produce $n + m$ digits of the product. 2511 2512Recall from sub-section 4.2.2 the definition of $\gamma$ as the number of bits in the type \textbf{mp\_digit}. We shall now extend the variable set to 2513include $\alpha$ which shall represent the number of bits in the type \textbf{mp\_word}. This implies that $2^{\alpha} > 2 \cdot \beta^2$. The 2514constant $\delta = 2^{\alpha - 2lg(\beta)}$ will represent the maximal weight of any column in a product (\textit{see sub-section 5.2.2 for more information}). 2515 2516\newpage\begin{figure}[!here] 2517\begin{small} 2518\begin{center} 2519\begin{tabular}{l} 2520\hline Algorithm \textbf{s\_mp\_mul\_digs}. \\ 2521\textbf{Input}. mp\_int $a$, mp\_int $b$ and an integer $digs$ \\ 2522\textbf{Output}. $c \leftarrow \vert a \vert \cdot \vert b \vert \mbox{ (mod }\beta^{digs}\mbox{)}$. \\ 2523\hline \\ 25241. If min$(a.used, b.used) < \delta$ then do \\ 2525\hspace{3mm}1.1 Calculate $c = \vert a \vert \cdot \vert b \vert$ by the Comba method (\textit{see algorithm~\ref{fig:COMBAMULT}}). \\ 2526\hspace{3mm}1.2 Return the result of step 1.1 \\ 2527\\ 2528Allocate and initialize a temporary mp\_int. \\ 25292. Init $t$ to be of size $digs$ \\ 25303. If step 2 failed return(\textit{MP\_MEM}). \\ 25314. $t.used \leftarrow digs$ \\ 2532\\ 2533Compute the product. \\ 25345. for $ix$ from $0$ to $a.used - 1$ do \\ 2535\hspace{3mm}5.1 $u \leftarrow 0$ \\ 2536\hspace{3mm}5.2 $pb \leftarrow \mbox{min}(b.used, digs - ix)$ \\ 2537\hspace{3mm}5.3 If $pb < 1$ then goto step 6. \\ 2538\hspace{3mm}5.4 for $iy$ from $0$ to $pb - 1$ do \\ 2539\hspace{6mm}5.4.1 $\hat r \leftarrow t_{iy + ix} + a_{ix} \cdot b_{iy} + u$ \\ 2540\hspace{6mm}5.4.2 $t_{iy + ix} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\ 2541\hspace{6mm}5.4.3 $u \leftarrow \lfloor \hat r / \beta \rfloor$ \\ 2542\hspace{3mm}5.5 if $ix + pb < digs$ then do \\ 2543\hspace{6mm}5.5.1 $t_{ix + pb} \leftarrow u$ \\ 25446. Clamp excess digits of $t$. \\ 25457. Swap $c$ with $t$ \\ 25468. Clear $t$ \\ 25479. Return(\textit{MP\_OKAY}). \\ 2548\hline 2549\end{tabular} 2550\end{center} 2551\end{small} 2552\caption{Algorithm s\_mp\_mul\_digs} 2553\end{figure} 2554 2555\textbf{Algorithm s\_mp\_mul\_digs.} 2556This algorithm computes the unsigned product of two inputs $a$ and $b$, limited to an output precision of $digs$ digits. While it may seem 2557a bit awkward to modify the function from its simple $O(n^2)$ description, the usefulness of partial multipliers will arise in a subsequent 2558algorithm. The algorithm is loosely based on algorithm 14.12 from \cite[pp. 595]{HAC} and is similar to Algorithm M of Knuth \cite[pp. 268]{TAOCPV2}. 2559Algorithm s\_mp\_mul\_digs differs from these cited references since it can produce a variable output precision regardless of the precision of the 2560inputs. 2561 2562The first thing this algorithm checks for is whether a Comba multiplier can be used instead. If the minimum digit count of either 2563input is less than $\delta$, then the Comba method may be used instead. After the Comba method is ruled out, the baseline algorithm begins. A 2564temporary mp\_int variable $t$ is used to hold the intermediate result of the product. This allows the algorithm to be used to 2565compute products when either $a = c$ or $b = c$ without overwriting the inputs. 2566 2567All of step 5 is the infamous $O(n^2)$ multiplication loop slightly modified to only produce upto $digs$ digits of output. The $pb$ variable 2568is given the count of digits to read from $b$ inside the nested loop. If $pb \le 1$ then no more output digits can be produced and the algorithm 2569will exit the loop. The best way to think of the loops are as a series of $pb \times 1$ multiplications. That is, in each pass of the 2570innermost loop $a_{ix}$ is multiplied against $b$ and the result is added (\textit{with an appropriate shift}) to $t$. 2571 2572For example, consider multiplying $576$ by $241$. That is equivalent to computing $10^0(1)(576) + 10^1(4)(576) + 10^2(2)(576)$ which is best 2573visualized in the following table. 2574 2575\begin{figure}[here] 2576\begin{center} 2577\begin{tabular}{|c|c|c|c|c|c|l|} 2578\hline && & 5 & 7 & 6 & \\ 2579\hline $\times$&& & 2 & 4 & 1 & \\ 2580\hline &&&&&&\\ 2581 && & 5 & 7 & 6 & $10^0(1)(576)$ \\ 2582 &2 & 3 & 6 & 1 & 6 & $10^1(4)(576) + 10^0(1)(576)$ \\ 2583 1 & 3 & 8 & 8 & 1 & 6 & $10^2(2)(576) + 10^1(4)(576) + 10^0(1)(576)$ \\ 2584\hline 2585\end{tabular} 2586\end{center} 2587\caption{Long-Hand Multiplication Diagram} 2588\end{figure} 2589 2590Each row of the product is added to the result after being shifted to the left (\textit{multiplied by a power of the radix}) by the appropriate 2591count. That is in pass $ix$ of the inner loop the product is added starting at the $ix$'th digit of the reult. 2592 2593Step 5.4.1 introduces the hat symbol (\textit{e.g. $\hat r$}) which represents a double precision variable. The multiplication on that step 2594is assumed to be a double wide output single precision multiplication. That is, two single precision variables are multiplied to produce a 2595double precision result. The step is somewhat optimized from a long-hand multiplication algorithm because the carry from the addition in step 25965.4.1 is propagated through the nested loop. If the carry was not propagated immediately it would overflow the single precision digit 2597$t_{ix+iy}$ and the result would be lost. 2598 2599At step 5.5 the nested loop is finished and any carry that was left over should be forwarded. The carry does not have to be added to the $ix+pb$'th 2600digit since that digit is assumed to be zero at this point. However, if $ix + pb \ge digs$ the carry is not set as it would make the result 2601exceed the precision requested. 2602 2603\vspace{+3mm}\begin{small} 2604\hspace{-5.1mm}{\bf File}: bn\_s\_mp\_mul\_digs.c 2605\vspace{-3mm} 2606\begin{alltt} 2607\end{alltt} 2608\end{small} 2609 2610First we determine (line 31) if the Comba method can be used first since it's faster. The conditions for 2611sing the Comba routine are that min$(a.used, b.used) < \delta$ and the number of digits of output is less than 2612\textbf{MP\_WARRAY}. This new constant is used to control the stack usage in the Comba routines. By default it is 2613set to $\delta$ but can be reduced when memory is at a premium. 2614 2615If we cannot use the Comba method we proceed to setup the baseline routine. We allocate the the destination mp\_int 2616$t$ (line 37) to the exact size of the output to avoid further re--allocations. At this point we now 2617begin the $O(n^2)$ loop. 2618 2619This implementation of multiplication has the caveat that it can be trimmed to only produce a variable number of 2620digits as output. In each iteration of the outer loop the $pb$ variable is set (line 49) to the maximum 2621number of inner loop iterations. 2622 2623Inside the inner loop we calculate $\hat r$ as the mp\_word product of the two mp\_digits and the addition of the 2624carry from the previous iteration. A particularly important observation is that most modern optimizing 2625C compilers (GCC for instance) can recognize that a $N \times N \rightarrow 2N$ multiplication is all that 2626is required for the product. In x86 terms for example, this means using the MUL instruction. 2627 2628Each digit of the product is stored in turn (line 69) and the carry propagated (line 72) to the 2629next iteration. 2630 2631\subsection{Faster Multiplication by the ``Comba'' Method} 2632 2633One of the huge drawbacks of the ``baseline'' algorithms is that at the $O(n^2)$ level the carry must be 2634computed and propagated upwards. This makes the nested loop very sequential and hard to unroll and implement 2635in parallel. The ``Comba'' \cite{COMBA} method is named after little known (\textit{in cryptographic venues}) Paul G. 2636Comba who described a method of implementing fast multipliers that do not require nested carry fixup operations. As an 2637interesting aside it seems that Paul Barrett describes a similar technique in his 1986 paper \cite{BARRETT} written 2638five years before. 2639 2640At the heart of the Comba technique is once again the long-hand algorithm. Except in this case a slight 2641twist is placed on how the columns of the result are produced. In the standard long-hand algorithm rows of products 2642are produced then added together to form the final result. In the baseline algorithm the columns are added together 2643after each iteration to get the result instantaneously. 2644 2645In the Comba algorithm the columns of the result are produced entirely independently of each other. That is at 2646the $O(n^2)$ level a simple multiplication and addition step is performed. The carries of the columns are propagated 2647after the nested loop to reduce the amount of work requiored. Succintly the first step of the algorithm is to compute 2648the product vector $\vec x$ as follows. 2649 2650\begin{equation} 2651\vec x_n = \sum_{i+j = n} a_ib_j, \forall n \in \lbrace 0, 1, 2, \ldots, i + j \rbrace 2652\end{equation} 2653 2654Where $\vec x_n$ is the $n'th$ column of the output vector. Consider the following example which computes the vector $\vec x$ for the multiplication 2655of $576$ and $241$. 2656 2657\newpage\begin{figure}[here] 2658\begin{small} 2659\begin{center} 2660\begin{tabular}{|c|c|c|c|c|c|} 2661 \hline & & 5 & 7 & 6 & First Input\\ 2662 \hline $\times$ & & 2 & 4 & 1 & Second Input\\ 2663\hline & & $1 \cdot 5 = 5$ & $1 \cdot 7 = 7$ & $1 \cdot 6 = 6$ & First pass \\ 2664 & $4 \cdot 5 = 20$ & $4 \cdot 7+5=33$ & $4 \cdot 6+7=31$ & 6 & Second pass \\ 2665 $2 \cdot 5 = 10$ & $2 \cdot 7 + 20 = 34$ & $2 \cdot 6+33=45$ & 31 & 6 & Third pass \\ 2666\hline 10 & 34 & 45 & 31 & 6 & Final Result \\ 2667\hline 2668\end{tabular} 2669\end{center} 2670\end{small} 2671\caption{Comba Multiplication Diagram} 2672\end{figure} 2673 2674At this point the vector $x = \left < 10, 34, 45, 31, 6 \right >$ is the result of the first step of the Comba multipler. 2675Now the columns must be fixed by propagating the carry upwards. The resultant vector will have one extra dimension over the input vector which is 2676congruent to adding a leading zero digit. 2677 2678\begin{figure}[!here] 2679\begin{small} 2680\begin{center} 2681\begin{tabular}{l} 2682\hline Algorithm \textbf{Comba Fixup}. \\ 2683\textbf{Input}. Vector $\vec x$ of dimension $k$ \\ 2684\textbf{Output}. Vector $\vec x$ such that the carries have been propagated. \\ 2685\hline \\ 26861. for $n$ from $0$ to $k - 1$ do \\ 2687\hspace{3mm}1.1 $\vec x_{n+1} \leftarrow \vec x_{n+1} + \lfloor \vec x_{n}/\beta \rfloor$ \\ 2688\hspace{3mm}1.2 $\vec x_{n} \leftarrow \vec x_{n} \mbox{ (mod }\beta\mbox{)}$ \\ 26892. Return($\vec x$). \\ 2690\hline 2691\end{tabular} 2692\end{center} 2693\end{small} 2694\caption{Algorithm Comba Fixup} 2695\end{figure} 2696 2697With that algorithm and $k = 5$ and $\beta = 10$ the following vector is produced $\vec x= \left < 1, 3, 8, 8, 1, 6 \right >$. In this case 2698$241 \cdot 576$ is in fact $138816$ and the procedure succeeded. If the algorithm is correct and as will be demonstrated shortly more 2699efficient than the baseline algorithm why not simply always use this algorithm? 2700 2701\subsubsection{Column Weight.} 2702At the nested $O(n^2)$ level the Comba method adds the product of two single precision variables to each column of the output 2703independently. A serious obstacle is if the carry is lost, due to lack of precision before the algorithm has a chance to fix 2704the carries. For example, in the multiplication of two three-digit numbers the third column of output will be the sum of 2705three single precision multiplications. If the precision of the accumulator for the output digits is less then $3 \cdot (\beta - 1)^2$ then 2706an overflow can occur and the carry information will be lost. For any $m$ and $n$ digit inputs the maximum weight of any column is 2707min$(m, n)$ which is fairly obvious. 2708 2709The maximum number of terms in any column of a product is known as the ``column weight'' and strictly governs when the algorithm can be used. Recall 2710from earlier that a double precision type has $\alpha$ bits of resolution and a single precision digit has $lg(\beta)$ bits of precision. Given these 2711two quantities we must not violate the following 2712 2713\begin{equation} 2714k \cdot \left (\beta - 1 \right )^2 < 2^{\alpha} 2715\end{equation} 2716 2717Which reduces to 2718 2719\begin{equation} 2720k \cdot \left ( \beta^2 - 2\beta + 1 \right ) < 2^{\alpha} 2721\end{equation} 2722 2723Let $\rho = lg(\beta)$ represent the number of bits in a single precision digit. By further re-arrangement of the equation the final solution is 2724found. 2725 2726\begin{equation} 2727k < {{2^{\alpha}} \over {\left (2^{2\rho} - 2^{\rho + 1} + 1 \right )}} 2728\end{equation} 2729 2730The defaults for LibTomMath are $\beta = 2^{28}$ and $\alpha = 2^{64}$ which means that $k$ is bounded by $k < 257$. In this configuration 2731the smaller input may not have more than $256$ digits if the Comba method is to be used. This is quite satisfactory for most applications since 2732$256$ digits would allow for numbers in the range of $0 \le x < 2^{7168}$ which, is much larger than most public key cryptographic algorithms require. 2733 2734\newpage\begin{figure}[!here] 2735\begin{small} 2736\begin{center} 2737\begin{tabular}{l} 2738\hline Algorithm \textbf{fast\_s\_mp\_mul\_digs}. \\ 2739\textbf{Input}. mp\_int $a$, mp\_int $b$ and an integer $digs$ \\ 2740\textbf{Output}. $c \leftarrow \vert a \vert \cdot \vert b \vert \mbox{ (mod }\beta^{digs}\mbox{)}$. \\ 2741\hline \\ 2742Place an array of \textbf{MP\_WARRAY} single precision digits named $W$ on the stack. \\ 27431. If $c.alloc < digs$ then grow $c$ to $digs$ digits. (\textit{mp\_grow}) \\ 27442. If step 1 failed return(\textit{MP\_MEM}).\\ 2745\\ 27463. $pa \leftarrow \mbox{MIN}(digs, a.used + b.used)$ \\ 2747\\ 27484. $\_ \hat W \leftarrow 0$ \\ 27495. for $ix$ from 0 to $pa - 1$ do \\ 2750\hspace{3mm}5.1 $ty \leftarrow \mbox{MIN}(b.used - 1, ix)$ \\ 2751\hspace{3mm}5.2 $tx \leftarrow ix - ty$ \\ 2752\hspace{3mm}5.3 $iy \leftarrow \mbox{MIN}(a.used - tx, ty + 1)$ \\ 2753\hspace{3mm}5.4 for $iz$ from 0 to $iy - 1$ do \\ 2754\hspace{6mm}5.4.1 $\_ \hat W \leftarrow \_ \hat W + a_{tx+iy}b_{ty-iy}$ \\ 2755\hspace{3mm}5.5 $W_{ix} \leftarrow \_ \hat W (\mbox{mod }\beta)$\\ 2756\hspace{3mm}5.6 $\_ \hat W \leftarrow \lfloor \_ \hat W / \beta \rfloor$ \\ 2757\\ 27586. $oldused \leftarrow c.used$ \\ 27597. $c.used \leftarrow digs$ \\ 27608. for $ix$ from $0$ to $pa$ do \\ 2761\hspace{3mm}8.1 $c_{ix} \leftarrow W_{ix}$ \\ 27629. for $ix$ from $pa + 1$ to $oldused - 1$ do \\ 2763\hspace{3mm}9.1 $c_{ix} \leftarrow 0$ \\ 2764\\ 276510. Clamp $c$. \\ 276611. Return MP\_OKAY. \\ 2767\hline 2768\end{tabular} 2769\end{center} 2770\end{small} 2771\caption{Algorithm fast\_s\_mp\_mul\_digs} 2772\label{fig:COMBAMULT} 2773\end{figure} 2774 2775\textbf{Algorithm fast\_s\_mp\_mul\_digs.} 2776This algorithm performs the unsigned multiplication of $a$ and $b$ using the Comba method limited to $digs$ digits of precision. 2777 2778The outer loop of this algorithm is more complicated than that of the baseline multiplier. This is because on the inside of the 2779loop we want to produce one column per pass. This allows the accumulator $\_ \hat W$ to be placed in CPU registers and 2780reduce the memory bandwidth to two \textbf{mp\_digit} reads per iteration. 2781 2782The $ty$ variable is set to the minimum count of $ix$ or the number of digits in $b$. That way if $a$ has more digits than 2783$b$ this will be limited to $b.used - 1$. The $tx$ variable is set to the to the distance past $b.used$ the variable 2784$ix$ is. This is used for the immediately subsequent statement where we find $iy$. 2785 2786The variable $iy$ is the minimum digits we can read from either $a$ or $b$ before running out. Computing one column at a time 2787means we have to scan one integer upwards and the other downwards. $a$ starts at $tx$ and $b$ starts at $ty$. In each 2788pass we are producing the $ix$'th output column and we note that $tx + ty = ix$. As we move $tx$ upwards we have to 2789move $ty$ downards so the equality remains valid. The $iy$ variable is the number of iterations until 2790$tx \ge a.used$ or $ty < 0$ occurs. 2791 2792After every inner pass we store the lower half of the accumulator into $W_{ix}$ and then propagate the carry of the accumulator 2793into the next round by dividing $\_ \hat W$ by $\beta$. 2794 2795To measure the benefits of the Comba method over the baseline method consider the number of operations that are required. If the 2796cost in terms of time of a multiply and addition is $p$ and the cost of a carry propagation is $q$ then a baseline multiplication would require 2797$O \left ((p + q)n^2 \right )$ time to multiply two $n$-digit numbers. The Comba method requires only $O(pn^2 + qn)$ time, however in practice, 2798the speed increase is actually much more. With $O(n)$ space the algorithm can be reduced to $O(pn + qn)$ time by implementing the $n$ multiply 2799and addition operations in the nested loop in parallel. 2800 2801\vspace{+3mm}\begin{small} 2802\hspace{-5.1mm}{\bf File}: bn\_fast\_s\_mp\_mul\_digs.c 2803\vspace{-3mm} 2804\begin{alltt} 2805\end{alltt} 2806\end{small} 2807 2808As per the pseudo--code we first calculate $pa$ (line 48) as the number of digits to output. Next we begin the outer loop 2809to produce the individual columns of the product. We use the two aliases $tmpx$ and $tmpy$ (lines 62, 63) to point 2810inside the two multiplicands quickly. 2811 2812The inner loop (lines 71 to 74) of this implementation is where the tradeoff come into play. Originally this comba 2813implementation was ``row--major'' which means it adds to each of the columns in each pass. After the outer loop it would then fix 2814the carries. This was very fast except it had an annoying drawback. You had to read a mp\_word and two mp\_digits and write 2815one mp\_word per iteration. On processors such as the Athlon XP and P4 this did not matter much since the cache bandwidth 2816is very high and it can keep the ALU fed with data. It did, however, matter on older and embedded cpus where cache is often 2817slower and also often doesn't exist. This new algorithm only performs two reads per iteration under the assumption that the 2818compiler has aliased $\_ \hat W$ to a CPU register. 2819 2820After the inner loop we store the current accumulator in $W$ and shift $\_ \hat W$ (lines 77, 80) to forward it as 2821a carry for the next pass. After the outer loop we use the final carry (line 77) as the last digit of the product. 2822 2823\subsection{Polynomial Basis Multiplication} 2824To break the $O(n^2)$ barrier in multiplication requires a completely different look at integer multiplication. In the following algorithms 2825the use of polynomial basis representation for two integers $a$ and $b$ as $f(x) = \sum_{i=0}^{n} a_i x^i$ and 2826$g(x) = \sum_{i=0}^{n} b_i x^i$ respectively, is required. In this system both $f(x)$ and $g(x)$ have $n + 1$ terms and are of the $n$'th degree. 2827 2828The product $a \cdot b \equiv f(x)g(x)$ is the polynomial $W(x) = \sum_{i=0}^{2n} w_i x^i$. The coefficients $w_i$ will 2829directly yield the desired product when $\beta$ is substituted for $x$. The direct solution to solve for the $2n + 1$ coefficients 2830requires $O(n^2)$ time and would in practice be slower than the Comba technique. 2831 2832However, numerical analysis theory indicates that only $2n + 1$ distinct points in $W(x)$ are required to determine the values of the $2n + 1$ unknown 2833coefficients. This means by finding $\zeta_y = W(y)$ for $2n + 1$ small values of $y$ the coefficients of $W(x)$ can be found with 2834Gaussian elimination. This technique is also occasionally refered to as the \textit{interpolation technique} (\textit{references please...}) since in 2835effect an interpolation based on $2n + 1$ points will yield a polynomial equivalent to $W(x)$. 2836 2837The coefficients of the polynomial $W(x)$ are unknown which makes finding $W(y)$ for any value of $y$ impossible. However, since 2838$W(x) = f(x)g(x)$ the equivalent $\zeta_y = f(y) g(y)$ can be used in its place. The benefit of this technique stems from the 2839fact that $f(y)$ and $g(y)$ are much smaller than either $a$ or $b$ respectively. As a result finding the $2n + 1$ relations required 2840by multiplying $f(y)g(y)$ involves multiplying integers that are much smaller than either of the inputs. 2841 2842When picking points to gather relations there are always three obvious points to choose, $y = 0, 1$ and $ \infty$. The $\zeta_0$ term 2843is simply the product $W(0) = w_0 = a_0 \cdot b_0$. The $\zeta_1$ term is the product 2844$W(1) = \left (\sum_{i = 0}^{n} a_i \right ) \left (\sum_{i = 0}^{n} b_i \right )$. The third point $\zeta_{\infty}$ is less obvious but rather 2845simple to explain. The $2n + 1$'th coefficient of $W(x)$ is numerically equivalent to the most significant column in an integer multiplication. 2846The point at $\infty$ is used symbolically to represent the most significant column, that is $W(\infty) = w_{2n} = a_nb_n$. Note that the 2847points at $y = 0$ and $\infty$ yield the coefficients $w_0$ and $w_{2n}$ directly. 2848 2849If more points are required they should be of small values and powers of two such as $2^q$ and the related \textit{mirror points} 2850$\left (2^q \right )^{2n} \cdot \zeta_{2^{-q}}$ for small values of $q$. The term ``mirror point'' stems from the fact that 2851$\left (2^q \right )^{2n} \cdot \zeta_{2^{-q}}$ can be calculated in the exact opposite fashion as $\zeta_{2^q}$. For 2852example, when $n = 2$ and $q = 1$ then following two equations are equivalent to the point $\zeta_{2}$ and its mirror. 2853 2854\begin{eqnarray} 2855\zeta_{2} = f(2)g(2) = (4a_2 + 2a_1 + a_0)(4b_2 + 2b_1 + b_0) \nonumber \\ 285616 \cdot \zeta_{1 \over 2} = 4f({1\over 2}) \cdot 4g({1 \over 2}) = (a_2 + 2a_1 + 4a_0)(b_2 + 2b_1 + 4b_0) 2857\end{eqnarray} 2858 2859Using such points will allow the values of $f(y)$ and $g(y)$ to be independently calculated using only left shifts. For example, when $n = 2$ the 2860polynomial $f(2^q)$ is equal to $2^q((2^qa_2) + a_1) + a_0$. This technique of polynomial representation is known as Horner's method. 2861 2862As a general rule of the algorithm when the inputs are split into $n$ parts each there are $2n - 1$ multiplications. Each multiplication is of 2863multiplicands that have $n$ times fewer digits than the inputs. The asymptotic running time of this algorithm is 2864$O \left ( k^{lg_n(2n - 1)} \right )$ for $k$ digit inputs (\textit{assuming they have the same number of digits}). Figure~\ref{fig:exponent} 2865summarizes the exponents for various values of $n$. 2866 2867\begin{figure} 2868\begin{center} 2869\begin{tabular}{|c|c|c|} 2870\hline \textbf{Split into $n$ Parts} & \textbf{Exponent} & \textbf{Notes}\\ 2871\hline $2$ & $1.584962501$ & This is Karatsuba Multiplication. \\ 2872\hline $3$ & $1.464973520$ & This is Toom-Cook Multiplication. \\ 2873\hline $4$ & $1.403677461$ &\\ 2874\hline $5$ & $1.365212389$ &\\ 2875\hline $10$ & $1.278753601$ &\\ 2876\hline $100$ & $1.149426538$ &\\ 2877\hline $1000$ & $1.100270931$ &\\ 2878\hline $10000$ & $1.075252070$ &\\ 2879\hline 2880\end{tabular} 2881\end{center} 2882\caption{Asymptotic Running Time of Polynomial Basis Multiplication} 2883\label{fig:exponent} 2884\end{figure} 2885 2886At first it may seem like a good idea to choose $n = 1000$ since the exponent is approximately $1.1$. However, the overhead 2887of solving for the 2001 terms of $W(x)$ will certainly consume any savings the algorithm could offer for all but exceedingly large 2888numbers. 2889 2890\subsubsection{Cutoff Point} 2891The polynomial basis multiplication algorithms all require fewer single precision multiplications than a straight Comba approach. However, 2892the algorithms incur an overhead (\textit{at the $O(n)$ work level}) since they require a system of equations to be solved. This makes the 2893polynomial basis approach more costly to use with small inputs. 2894 2895Let $m$ represent the number of digits in the multiplicands (\textit{assume both multiplicands have the same number of digits}). There exists a 2896point $y$ such that when $m < y$ the polynomial basis algorithms are more costly than Comba, when $m = y$ they are roughly the same cost and 2897when $m > y$ the Comba methods are slower than the polynomial basis algorithms. 2898 2899The exact location of $y$ depends on several key architectural elements of the computer platform in question. 2900 2901\begin{enumerate} 2902\item The ratio of clock cycles for single precision multiplication versus other simpler operations such as addition, shifting, etc. For example 2903on the AMD Athlon the ratio is roughly $17 : 1$ while on the Intel P4 it is $29 : 1$. The higher the ratio in favour of multiplication the lower 2904the cutoff point $y$ will be. 2905 2906\item The complexity of the linear system of equations (\textit{for the coefficients of $W(x)$}) is. Generally speaking as the number of splits 2907grows the complexity grows substantially. Ideally solving the system will only involve addition, subtraction and shifting of integers. This 2908directly reflects on the ratio previous mentioned. 2909 2910\item To a lesser extent memory bandwidth and function call overheads. Provided the values are in the processor cache this is less of an 2911influence over the cutoff point. 2912 2913\end{enumerate} 2914 2915A clean cutoff point separation occurs when a point $y$ is found such that all of the cutoff point conditions are met. For example, if the point 2916is too low then there will be values of $m$ such that $m > y$ and the Comba method is still faster. Finding the cutoff points is fairly simple when 2917a high resolution timer is available. 2918 2919\subsection{Karatsuba Multiplication} 2920Karatsuba \cite{KARA} multiplication when originally proposed in 1962 was among the first set of algorithms to break the $O(n^2)$ barrier for 2921general purpose multiplication. Given two polynomial basis representations $f(x) = ax + b$ and $g(x) = cx + d$, Karatsuba proved with 2922light algebra \cite{KARAP} that the following polynomial is equivalent to multiplication of the two integers the polynomials represent. 2923 2924\begin{equation} 2925f(x) \cdot g(x) = acx^2 + ((a + b)(c + d) - (ac + bd))x + bd 2926\end{equation} 2927 2928Using the observation that $ac$ and $bd$ could be re-used only three half sized multiplications would be required to produce the product. Applying 2929this algorithm recursively, the work factor becomes $O(n^{lg(3)})$ which is substantially better than the work factor $O(n^2)$ of the Comba technique. It turns 2930out what Karatsuba did not know or at least did not publish was that this is simply polynomial basis multiplication with the points 2931$\zeta_0$, $\zeta_{\infty}$ and $\zeta_{1}$. Consider the resultant system of equations. 2932 2933\begin{center} 2934\begin{tabular}{rcrcrcrc} 2935$\zeta_{0}$ & $=$ & & & & & $w_0$ \\ 2936$\zeta_{1}$ & $=$ & $w_2$ & $+$ & $w_1$ & $+$ & $w_0$ \\ 2937$\zeta_{\infty}$ & $=$ & $w_2$ & & & & \\ 2938\end{tabular} 2939\end{center} 2940 2941By adding the first and last equation to the equation in the middle the term $w_1$ can be isolated and all three coefficients solved for. The simplicity 2942of this system of equations has made Karatsuba fairly popular. In fact the cutoff point is often fairly low\footnote{With LibTomMath 0.18 it is 70 and 109 digits for the Intel P4 and AMD Athlon respectively.} 2943making it an ideal algorithm to speed up certain public key cryptosystems such as RSA and Diffie-Hellman. 2944 2945\newpage\begin{figure}[!here] 2946\begin{small} 2947\begin{center} 2948\begin{tabular}{l} 2949\hline Algorithm \textbf{mp\_karatsuba\_mul}. \\ 2950\textbf{Input}. mp\_int $a$ and mp\_int $b$ \\ 2951\textbf{Output}. $c \leftarrow \vert a \vert \cdot \vert b \vert$ \\ 2952\hline \\ 29531. Init the following mp\_int variables: $x0$, $x1$, $y0$, $y1$, $t1$, $x0y0$, $x1y1$.\\ 29542. If step 2 failed then return(\textit{MP\_MEM}). \\ 2955\\ 2956Split the input. e.g. $a = x1 \cdot \beta^B + x0$ \\ 29573. $B \leftarrow \mbox{min}(a.used, b.used)/2$ \\ 29584. $x0 \leftarrow a \mbox{ (mod }\beta^B\mbox{)}$ (\textit{mp\_mod\_2d}) \\ 29595. $y0 \leftarrow b \mbox{ (mod }\beta^B\mbox{)}$ \\ 29606. $x1 \leftarrow \lfloor a / \beta^B \rfloor$ (\textit{mp\_rshd}) \\ 29617. $y1 \leftarrow \lfloor b / \beta^B \rfloor$ \\ 2962\\ 2963Calculate the three products. \\ 29648. $x0y0 \leftarrow x0 \cdot y0$ (\textit{mp\_mul}) \\ 29659. $x1y1 \leftarrow x1 \cdot y1$ \\ 296610. $t1 \leftarrow x1 + x0$ (\textit{mp\_add}) \\ 296711. $x0 \leftarrow y1 + y0$ \\ 296812. $t1 \leftarrow t1 \cdot x0$ \\ 2969\\ 2970Calculate the middle term. \\ 297113. $x0 \leftarrow x0y0 + x1y1$ \\ 297214. $t1 \leftarrow t1 - x0$ (\textit{s\_mp\_sub}) \\ 2973\\ 2974Calculate the final product. \\ 297515. $t1 \leftarrow t1 \cdot \beta^B$ (\textit{mp\_lshd}) \\ 297616. $x1y1 \leftarrow x1y1 \cdot \beta^{2B}$ \\ 297717. $t1 \leftarrow x0y0 + t1$ \\ 297818. $c \leftarrow t1 + x1y1$ \\ 297919. Clear all of the temporary variables. \\ 298020. Return(\textit{MP\_OKAY}).\\ 2981\hline 2982\end{tabular} 2983\end{center} 2984\end{small} 2985\caption{Algorithm mp\_karatsuba\_mul} 2986\end{figure} 2987 2988\textbf{Algorithm mp\_karatsuba\_mul.} 2989This algorithm computes the unsigned product of two inputs using the Karatsuba multiplication algorithm. It is loosely based on the description 2990from Knuth \cite[pp. 294-295]{TAOCPV2}. 2991 2992\index{radix point} 2993In order to split the two inputs into their respective halves, a suitable \textit{radix point} must be chosen. The radix point chosen must 2994be used for both of the inputs meaning that it must be smaller than the smallest input. Step 3 chooses the radix point $B$ as half of the 2995smallest input \textbf{used} count. After the radix point is chosen the inputs are split into lower and upper halves. Step 4 and 5 2996compute the lower halves. Step 6 and 7 computer the upper halves. 2997 2998After the halves have been computed the three intermediate half-size products must be computed. Step 8 and 9 compute the trivial products 2999$x0 \cdot y0$ and $x1 \cdot y1$. The mp\_int $x0$ is used as a temporary variable after $x1 + x0$ has been computed. By using $x0$ instead 3000of an additional temporary variable, the algorithm can avoid an addition memory allocation operation. 3001 3002The remaining steps 13 through 18 compute the Karatsuba polynomial through a variety of digit shifting and addition operations. 3003 3004\vspace{+3mm}\begin{small} 3005\hspace{-5.1mm}{\bf File}: bn\_mp\_karatsuba\_mul.c 3006\vspace{-3mm} 3007\begin{alltt} 3008\end{alltt} 3009\end{small} 3010 3011The new coding element in this routine, not seen in previous routines, is the usage of goto statements. The conventional 3012wisdom is that goto statements should be avoided. This is generally true, however when every single function call can fail, it makes sense 3013to handle error recovery with a single piece of code. Lines 62 to 76 handle initializing all of the temporary variables 3014required. Note how each of the if statements goes to a different label in case of failure. This allows the routine to correctly free only 3015the temporaries that have been successfully allocated so far. 3016 3017The temporary variables are all initialized using the mp\_init\_size routine since they are expected to be large. This saves the 3018additional reallocation that would have been necessary. Also $x0$, $x1$, $y0$ and $y1$ have to be able to hold at least their respective 3019number of digits for the next section of code. 3020 3021The first algebraic portion of the algorithm is to split the two inputs into their halves. However, instead of using mp\_mod\_2d and mp\_rshd 3022to extract the halves, the respective code has been placed inline within the body of the function. To initialize the halves, the \textbf{used} and 3023\textbf{sign} members are copied first. The first for loop on line 96 copies the lower halves. Since they are both the same magnitude it 3024is simpler to calculate both lower halves in a single loop. The for loop on lines 102 and 107 calculate the upper halves $x1$ and 3025$y1$ respectively. 3026 3027By inlining the calculation of the halves, the Karatsuba multiplier has a slightly lower overhead and can be used for smaller magnitude inputs. 3028 3029When line 151 is reached, the algorithm has completed succesfully. The ``error status'' variable $err$ is set to \textbf{MP\_OKAY} so that 3030the same code that handles errors can be used to clear the temporary variables and return. 3031 3032\subsection{Toom-Cook $3$-Way Multiplication} 3033Toom-Cook $3$-Way \cite{TOOM} multiplication is essentially the polynomial basis algorithm for $n = 2$ except that the points are 3034chosen such that $\zeta$ is easy to compute and the resulting system of equations easy to reduce. Here, the points $\zeta_{0}$, 3035$16 \cdot \zeta_{1 \over 2}$, $\zeta_1$, $\zeta_2$ and $\zeta_{\infty}$ make up the five required points to solve for the coefficients 3036of the $W(x)$. 3037 3038With the five relations that Toom-Cook specifies, the following system of equations is formed. 3039 3040\begin{center} 3041\begin{tabular}{rcrcrcrcrcr} 3042$\zeta_0$ & $=$ & $0w_4$ & $+$ & $0w_3$ & $+$ & $0w_2$ & $+$ & $0w_1$ & $+$ & $1w_0$ \\ 3043$16 \cdot \zeta_{1 \over 2}$ & $=$ & $1w_4$ & $+$ & $2w_3$ & $+$ & $4w_2$ & $+$ & $8w_1$ & $+$ & $16w_0$ \\ 3044$\zeta_1$ & $=$ & $1w_4$ & $+$ & $1w_3$ & $+$ & $1w_2$ & $+$ & $1w_1$ & $+$ & $1w_0$ \\ 3045$\zeta_2$ & $=$ & $16w_4$ & $+$ & $8w_3$ & $+$ & $4w_2$ & $+$ & $2w_1$ & $+$ & $1w_0$ \\ 3046$\zeta_{\infty}$ & $=$ & $1w_4$ & $+$ & $0w_3$ & $+$ & $0w_2$ & $+$ & $0w_1$ & $+$ & $0w_0$ \\ 3047\end{tabular} 3048\end{center} 3049 3050A trivial solution to this matrix requires $12$ subtractions, two multiplications by a small power of two, two divisions by a small power 3051of two, two divisions by three and one multiplication by three. All of these $19$ sub-operations require less than quadratic time, meaning that 3052the algorithm can be faster than a baseline multiplication. However, the greater complexity of this algorithm places the cutoff point 3053(\textbf{TOOM\_MUL\_CUTOFF}) where Toom-Cook becomes more efficient much higher than the Karatsuba cutoff point. 3054 3055\begin{figure}[!here] 3056\begin{small} 3057\begin{center} 3058\begin{tabular}{l} 3059\hline Algorithm \textbf{mp\_toom\_mul}. \\ 3060\textbf{Input}. mp\_int $a$ and mp\_int $b$ \\ 3061\textbf{Output}. $c \leftarrow a \cdot b $ \\ 3062\hline \\ 3063Split $a$ and $b$ into three pieces. E.g. $a = a_2 \beta^{2k} + a_1 \beta^{k} + a_0$ \\ 30641. $k \leftarrow \lfloor \mbox{min}(a.used, b.used) / 3 \rfloor$ \\ 30652. $a_0 \leftarrow a \mbox{ (mod }\beta^{k}\mbox{)}$ \\ 30663. $a_1 \leftarrow \lfloor a / \beta^k \rfloor$, $a_1 \leftarrow a_1 \mbox{ (mod }\beta^{k}\mbox{)}$ \\ 30674. $a_2 \leftarrow \lfloor a / \beta^{2k} \rfloor$, $a_2 \leftarrow a_2 \mbox{ (mod }\beta^{k}\mbox{)}$ \\ 30685. $b_0 \leftarrow a \mbox{ (mod }\beta^{k}\mbox{)}$ \\ 30696. $b_1 \leftarrow \lfloor a / \beta^k \rfloor$, $b_1 \leftarrow b_1 \mbox{ (mod }\beta^{k}\mbox{)}$ \\ 30707. $b_2 \leftarrow \lfloor a / \beta^{2k} \rfloor$, $b_2 \leftarrow b_2 \mbox{ (mod }\beta^{k}\mbox{)}$ \\ 3071\\ 3072Find the five equations for $w_0, w_1, ..., w_4$. \\ 30738. $w_0 \leftarrow a_0 \cdot b_0$ \\ 30749. $w_4 \leftarrow a_2 \cdot b_2$ \\ 307510. $tmp_1 \leftarrow 2 \cdot a_0$, $tmp_1 \leftarrow a_1 + tmp_1$, $tmp_1 \leftarrow 2 \cdot tmp_1$, $tmp_1 \leftarrow tmp_1 + a_2$ \\ 307611. $tmp_2 \leftarrow 2 \cdot b_0$, $tmp_2 \leftarrow b_1 + tmp_2$, $tmp_2 \leftarrow 2 \cdot tmp_2$, $tmp_2 \leftarrow tmp_2 + b_2$ \\ 307712. $w_1 \leftarrow tmp_1 \cdot tmp_2$ \\ 307813. $tmp_1 \leftarrow 2 \cdot a_2$, $tmp_1 \leftarrow a_1 + tmp_1$, $tmp_1 \leftarrow 2 \cdot tmp_1$, $tmp_1 \leftarrow tmp_1 + a_0$ \\ 307914. $tmp_2 \leftarrow 2 \cdot b_2$, $tmp_2 \leftarrow b_1 + tmp_2$, $tmp_2 \leftarrow 2 \cdot tmp_2$, $tmp_2 \leftarrow tmp_2 + b_0$ \\ 308015. $w_3 \leftarrow tmp_1 \cdot tmp_2$ \\ 308116. $tmp_1 \leftarrow a_0 + a_1$, $tmp_1 \leftarrow tmp_1 + a_2$, $tmp_2 \leftarrow b_0 + b_1$, $tmp_2 \leftarrow tmp_2 + b_2$ \\ 308217. $w_2 \leftarrow tmp_1 \cdot tmp_2$ \\ 3083\\ 3084Continued on the next page.\\ 3085\hline 3086\end{tabular} 3087\end{center} 3088\end{small} 3089\caption{Algorithm mp\_toom\_mul} 3090\end{figure} 3091 3092\newpage\begin{figure}[!here] 3093\begin{small} 3094\begin{center} 3095\begin{tabular}{l} 3096\hline Algorithm \textbf{mp\_toom\_mul} (continued). \\ 3097\textbf{Input}. mp\_int $a$ and mp\_int $b$ \\ 3098\textbf{Output}. $c \leftarrow a \cdot b $ \\ 3099\hline \\ 3100Now solve the system of equations. \\ 310118. $w_1 \leftarrow w_4 - w_1$, $w_3 \leftarrow w_3 - w_0$ \\ 310219. $w_1 \leftarrow \lfloor w_1 / 2 \rfloor$, $w_3 \leftarrow \lfloor w_3 / 2 \rfloor$ \\ 310320. $w_2 \leftarrow w_2 - w_0$, $w_2 \leftarrow w_2 - w_4$ \\ 310421. $w_1 \leftarrow w_1 - w_2$, $w_3 \leftarrow w_3 - w_2$ \\ 310522. $tmp_1 \leftarrow 8 \cdot w_0$, $w_1 \leftarrow w_1 - tmp_1$, $tmp_1 \leftarrow 8 \cdot w_4$, $w_3 \leftarrow w_3 - tmp_1$ \\ 310623. $w_2 \leftarrow 3 \cdot w_2$, $w_2 \leftarrow w_2 - w_1$, $w_2 \leftarrow w_2 - w_3$ \\ 310724. $w_1 \leftarrow w_1 - w_2$, $w_3 \leftarrow w_3 - w_2$ \\ 310825. $w_1 \leftarrow \lfloor w_1 / 3 \rfloor, w_3 \leftarrow \lfloor w_3 / 3 \rfloor$ \\ 3109\\ 3110Now substitute $\beta^k$ for $x$ by shifting $w_0, w_1, ..., w_4$. \\ 311126. for $n$ from $1$ to $4$ do \\ 3112\hspace{3mm}26.1 $w_n \leftarrow w_n \cdot \beta^{nk}$ \\ 311327. $c \leftarrow w_0 + w_1$, $c \leftarrow c + w_2$, $c \leftarrow c + w_3$, $c \leftarrow c + w_4$ \\ 311428. Return(\textit{MP\_OKAY}) \\ 3115\hline 3116\end{tabular} 3117\end{center} 3118\end{small} 3119\caption{Algorithm mp\_toom\_mul (continued)} 3120\end{figure} 3121 3122\textbf{Algorithm mp\_toom\_mul.} 3123This algorithm computes the product of two mp\_int variables $a$ and $b$ using the Toom-Cook approach. Compared to the Karatsuba multiplication, this 3124algorithm has a lower asymptotic running time of approximately $O(n^{1.464})$ but at an obvious cost in overhead. In this 3125description, several statements have been compounded to save space. The intention is that the statements are executed from left to right across 3126any given step. 3127 3128The two inputs $a$ and $b$ are first split into three $k$-digit integers $a_0, a_1, a_2$ and $b_0, b_1, b_2$ respectively. From these smaller 3129integers the coefficients of the polynomial basis representations $f(x)$ and $g(x)$ are known and can be used to find the relations required. 3130 3131The first two relations $w_0$ and $w_4$ are the points $\zeta_{0}$ and $\zeta_{\infty}$ respectively. The relation $w_1, w_2$ and $w_3$ correspond 3132to the points $16 \cdot \zeta_{1 \over 2}, \zeta_{2}$ and $\zeta_{1}$ respectively. These are found using logical shifts to independently find 3133$f(y)$ and $g(y)$ which significantly speeds up the algorithm. 3134 3135After the five relations $w_0, w_1, \ldots, w_4$ have been computed, the system they represent must be solved in order for the unknown coefficients 3136$w_1, w_2$ and $w_3$ to be isolated. The steps 18 through 25 perform the system reduction required as previously described. Each step of 3137the reduction represents the comparable matrix operation that would be performed had this been performed by pencil. For example, step 18 indicates 3138that row $1$ must be subtracted from row $4$ and simultaneously row $0$ subtracted from row $3$. 3139 3140Once the coeffients have been isolated, the polynomial $W(x) = \sum_{i=0}^{2n} w_i x^i$ is known. By substituting $\beta^{k}$ for $x$, the integer 3141result $a \cdot b$ is produced. 3142 3143\vspace{+3mm}\begin{small} 3144\hspace{-5.1mm}{\bf File}: bn\_mp\_toom\_mul.c 3145\vspace{-3mm} 3146\begin{alltt} 3147\end{alltt} 3148\end{small} 3149 3150The first obvious thing to note is that this algorithm is complicated. The complexity is worth it if you are multiplying very 3151large numbers. For example, a 10,000 digit multiplication takes approximaly 99,282,205 fewer single precision multiplications with 3152Toom--Cook than a Comba or baseline approach (this is a savings of more than 99$\%$). For most ``crypto'' sized numbers this 3153algorithm is not practical as Karatsuba has a much lower cutoff point. 3154 3155First we split $a$ and $b$ into three roughly equal portions. This has been accomplished (lines 41 to 70) with 3156combinations of mp\_rshd() and mp\_mod\_2d() function calls. At this point $a = a2 \cdot \beta^2 + a1 \cdot \beta + a0$ and similiarly 3157for $b$. 3158 3159Next we compute the five points $w0, w1, w2, w3$ and $w4$. Recall that $w0$ and $w4$ can be computed directly from the portions so 3160we get those out of the way first (lines 73 and 78). Next we compute $w1, w2$ and $w3$ using Horners method. 3161 3162After this point we solve for the actual values of $w1, w2$ and $w3$ by reducing the $5 \times 5$ system which is relatively 3163straight forward. 3164 3165\subsection{Signed Multiplication} 3166Now that algorithms to handle multiplications of every useful dimensions have been developed, a rather simple finishing touch is required. So far all 3167of the multiplication algorithms have been unsigned multiplications which leaves only a signed multiplication algorithm to be established. 3168 3169\begin{figure}[!here] 3170\begin{small} 3171\begin{center} 3172\begin{tabular}{l} 3173\hline Algorithm \textbf{mp\_mul}. \\ 3174\textbf{Input}. mp\_int $a$ and mp\_int $b$ \\ 3175\textbf{Output}. $c \leftarrow a \cdot b$ \\ 3176\hline \\ 31771. If $a.sign = b.sign$ then \\ 3178\hspace{3mm}1.1 $sign = MP\_ZPOS$ \\ 31792. else \\ 3180\hspace{3mm}2.1 $sign = MP\_ZNEG$ \\ 31813. If min$(a.used, b.used) \ge TOOM\_MUL\_CUTOFF$ then \\ 3182\hspace{3mm}3.1 $c \leftarrow a \cdot b$ using algorithm mp\_toom\_mul \\ 31834. else if min$(a.used, b.used) \ge KARATSUBA\_MUL\_CUTOFF$ then \\ 3184\hspace{3mm}4.1 $c \leftarrow a \cdot b$ using algorithm mp\_karatsuba\_mul \\ 31855. else \\ 3186\hspace{3mm}5.1 $digs \leftarrow a.used + b.used + 1$ \\ 3187\hspace{3mm}5.2 If $digs < MP\_ARRAY$ and min$(a.used, b.used) \le \delta$ then \\ 3188\hspace{6mm}5.2.1 $c \leftarrow a \cdot b \mbox{ (mod }\beta^{digs}\mbox{)}$ using algorithm fast\_s\_mp\_mul\_digs. \\ 3189\hspace{3mm}5.3 else \\ 3190\hspace{6mm}5.3.1 $c \leftarrow a \cdot b \mbox{ (mod }\beta^{digs}\mbox{)}$ using algorithm s\_mp\_mul\_digs. \\ 31916. $c.sign \leftarrow sign$ \\ 31927. Return the result of the unsigned multiplication performed. \\ 3193\hline 3194\end{tabular} 3195\end{center} 3196\end{small} 3197\caption{Algorithm mp\_mul} 3198\end{figure} 3199 3200\textbf{Algorithm mp\_mul.} 3201This algorithm performs the signed multiplication of two inputs. It will make use of any of the three unsigned multiplication algorithms 3202available when the input is of appropriate size. The \textbf{sign} of the result is not set until the end of the algorithm since algorithm 3203s\_mp\_mul\_digs will clear it. 3204 3205\vspace{+3mm}\begin{small} 3206\hspace{-5.1mm}{\bf File}: bn\_mp\_mul.c 3207\vspace{-3mm} 3208\begin{alltt} 3209\end{alltt} 3210\end{small} 3211 3212The implementation is rather simplistic and is not particularly noteworthy. Line 22 computes the sign of the result using the ``?'' 3213operator from the C programming language. Line 48 computes $\delta$ using the fact that $1 << k$ is equal to $2^k$. 3214 3215\section{Squaring} 3216\label{sec:basesquare} 3217 3218Squaring is a special case of multiplication where both multiplicands are equal. At first it may seem like there is no significant optimization 3219available but in fact there is. Consider the multiplication of $576$ against $241$. In total there will be nine single precision multiplications 3220performed which are $1\cdot 6$, $1 \cdot 7$, $1 \cdot 5$, $4 \cdot 6$, $4 \cdot 7$, $4 \cdot 5$, $2 \cdot 6$, $2 \cdot 7$ and $2 \cdot 5$. Now consider 3221the multiplication of $123$ against $123$. The nine products are $3 \cdot 3$, $3 \cdot 2$, $3 \cdot 1$, $2 \cdot 3$, $2 \cdot 2$, $2 \cdot 1$, 3222$1 \cdot 3$, $1 \cdot 2$ and $1 \cdot 1$. On closer inspection some of the products are equivalent. For example, $3 \cdot 2 = 2 \cdot 3$ 3223and $3 \cdot 1 = 1 \cdot 3$. 3224 3225For any $n$-digit input, there are ${{\left (n^2 + n \right)}\over 2}$ possible unique single precision multiplications required compared to the $n^2$ 3226required for multiplication. The following diagram gives an example of the operations required. 3227 3228\begin{figure}[here] 3229\begin{center} 3230\begin{tabular}{ccccc|c} 3231&&1&2&3&\\ 3232$\times$ &&1&2&3&\\ 3233\hline && $3 \cdot 1$ & $3 \cdot 2$ & $3 \cdot 3$ & Row 0\\ 3234 & $2 \cdot 1$ & $2 \cdot 2$ & $2 \cdot 3$ && Row 1 \\ 3235 $1 \cdot 1$ & $1 \cdot 2$ & $1 \cdot 3$ &&& Row 2 \\ 3236\end{tabular} 3237\end{center} 3238\caption{Squaring Optimization Diagram} 3239\end{figure} 3240 3241Starting from zero and numbering the columns from right to left a very simple pattern becomes obvious. For the purposes of this discussion let $x$ 3242represent the number being squared. The first observation is that in row $k$ the $2k$'th column of the product has a $\left (x_k \right)^2$ term in it. 3243 3244The second observation is that every column $j$ in row $k$ where $j \ne 2k$ is part of a double product. Every non-square term of a column will 3245appear twice hence the name ``double product''. Every odd column is made up entirely of double products. In fact every column is made up of double 3246products and at most one square (\textit{see the exercise section}). 3247 3248The third and final observation is that for row $k$ the first unique non-square term, that is, one that hasn't already appeared in an earlier row, 3249occurs at column $2k + 1$. For example, on row $1$ of the previous squaring, column one is part of the double product with column one from row zero. 3250Column two of row one is a square and column three is the first unique column. 3251 3252\subsection{The Baseline Squaring Algorithm} 3253The baseline squaring algorithm is meant to be a catch-all squaring algorithm. It will handle any of the input sizes that the faster routines 3254will not handle. 3255 3256\begin{figure}[!here] 3257\begin{small} 3258\begin{center} 3259\begin{tabular}{l} 3260\hline Algorithm \textbf{s\_mp\_sqr}. \\ 3261\textbf{Input}. mp\_int $a$ \\ 3262\textbf{Output}. $b \leftarrow a^2$ \\ 3263\hline \\ 32641. Init a temporary mp\_int of at least $2 \cdot a.used +1$ digits. (\textit{mp\_init\_size}) \\ 32652. If step 1 failed return(\textit{MP\_MEM}) \\ 32663. $t.used \leftarrow 2 \cdot a.used + 1$ \\ 32674. For $ix$ from 0 to $a.used - 1$ do \\ 3268\hspace{3mm}Calculate the square. \\ 3269\hspace{3mm}4.1 $\hat r \leftarrow t_{2ix} + \left (a_{ix} \right )^2$ \\ 3270\hspace{3mm}4.2 $t_{2ix} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\ 3271\hspace{3mm}Calculate the double products after the square. \\ 3272\hspace{3mm}4.3 $u \leftarrow \lfloor \hat r / \beta \rfloor$ \\ 3273\hspace{3mm}4.4 For $iy$ from $ix + 1$ to $a.used - 1$ do \\ 3274\hspace{6mm}4.4.1 $\hat r \leftarrow 2 \cdot a_{ix}a_{iy} + t_{ix + iy} + u$ \\ 3275\hspace{6mm}4.4.2 $t_{ix + iy} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\ 3276\hspace{6mm}4.4.3 $u \leftarrow \lfloor \hat r / \beta \rfloor$ \\ 3277\hspace{3mm}Set the last carry. \\ 3278\hspace{3mm}4.5 While $u > 0$ do \\ 3279\hspace{6mm}4.5.1 $iy \leftarrow iy + 1$ \\ 3280\hspace{6mm}4.5.2 $\hat r \leftarrow t_{ix + iy} + u$ \\ 3281\hspace{6mm}4.5.3 $t_{ix + iy} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\ 3282\hspace{6mm}4.5.4 $u \leftarrow \lfloor \hat r / \beta \rfloor$ \\ 32835. Clamp excess digits of $t$. (\textit{mp\_clamp}) \\ 32846. Exchange $b$ and $t$. \\ 32857. Clear $t$ (\textit{mp\_clear}) \\ 32868. Return(\textit{MP\_OKAY}) \\ 3287\hline 3288\end{tabular} 3289\end{center} 3290\end{small} 3291\caption{Algorithm s\_mp\_sqr} 3292\end{figure} 3293 3294\textbf{Algorithm s\_mp\_sqr.} 3295This algorithm computes the square of an input using the three observations on squaring. It is based fairly faithfully on algorithm 14.16 of HAC 3296\cite[pp.596-597]{HAC}. Similar to algorithm s\_mp\_mul\_digs, a temporary mp\_int is allocated to hold the result of the squaring. This allows the 3297destination mp\_int to be the same as the source mp\_int. 3298 3299The outer loop of this algorithm begins on step 4. It is best to think of the outer loop as walking down the rows of the partial results, while 3300the inner loop computes the columns of the partial result. Step 4.1 and 4.2 compute the square term for each row, and step 4.3 and 4.4 propagate 3301the carry and compute the double products. 3302 3303The requirement that a mp\_word be able to represent the range $0 \le x < 2 \beta^2$ arises from this 3304very algorithm. The product $a_{ix}a_{iy}$ will lie in the range $0 \le x \le \beta^2 - 2\beta + 1$ which is obviously less than $\beta^2$ meaning that 3305when it is multiplied by two, it can be properly represented by a mp\_word. 3306 3307Similar to algorithm s\_mp\_mul\_digs, after every pass of the inner loop, the destination is correctly set to the sum of all of the partial 3308results calculated so far. This involves expensive carry propagation which will be eliminated in the next algorithm. 3309 3310\vspace{+3mm}\begin{small} 3311\hspace{-5.1mm}{\bf File}: bn\_s\_mp\_sqr.c 3312\vspace{-3mm} 3313\begin{alltt} 3314\end{alltt} 3315\end{small} 3316 3317Inside the outer loop (line 34) the square term is calculated on line 37. The carry (line 44) has been 3318extracted from the mp\_word accumulator using a right shift. Aliases for $a_{ix}$ and $t_{ix+iy}$ are initialized 3319(lines 47 and 50) to simplify the inner loop. The doubling is performed using two 3320additions (line 59) since it is usually faster than shifting, if not at least as fast. 3321 3322The important observation is that the inner loop does not begin at $iy = 0$ like for multiplication. As such the inner loops 3323get progressively shorter as the algorithm proceeds. This is what leads to the savings compared to using a multiplication to 3324square a number. 3325 3326\subsection{Faster Squaring by the ``Comba'' Method} 3327A major drawback to the baseline method is the requirement for single precision shifting inside the $O(n^2)$ nested loop. Squaring has an additional 3328drawback that it must double the product inside the inner loop as well. As for multiplication, the Comba technique can be used to eliminate these 3329performance hazards. 3330 3331The first obvious solution is to make an array of mp\_words which will hold all of the columns. This will indeed eliminate all of the carry 3332propagation operations from the inner loop. However, the inner product must still be doubled $O(n^2)$ times. The solution stems from the simple fact 3333that $2a + 2b + 2c = 2(a + b + c)$. That is the sum of all of the double products is equal to double the sum of all the products. For example, 3334$ab + ba + ac + ca = 2ab + 2ac = 2(ab + ac)$. 3335 3336However, we cannot simply double all of the columns, since the squares appear only once per row. The most practical solution is to have two 3337mp\_word arrays. One array will hold the squares and the other array will hold the double products. With both arrays the doubling and 3338carry propagation can be moved to a $O(n)$ work level outside the $O(n^2)$ level. In this case, we have an even simpler solution in mind. 3339 3340\newpage\begin{figure}[!here] 3341\begin{small} 3342\begin{center} 3343\begin{tabular}{l} 3344\hline Algorithm \textbf{fast\_s\_mp\_sqr}. \\ 3345\textbf{Input}. mp\_int $a$ \\ 3346\textbf{Output}. $b \leftarrow a^2$ \\ 3347\hline \\ 3348Place an array of \textbf{MP\_WARRAY} mp\_digits named $W$ on the stack. \\ 33491. If $b.alloc < 2a.used + 1$ then grow $b$ to $2a.used + 1$ digits. (\textit{mp\_grow}). \\ 33502. If step 1 failed return(\textit{MP\_MEM}). \\ 3351\\ 33523. $pa \leftarrow 2 \cdot a.used$ \\ 33534. $\hat W1 \leftarrow 0$ \\ 33545. for $ix$ from $0$ to $pa - 1$ do \\ 3355\hspace{3mm}5.1 $\_ \hat W \leftarrow 0$ \\ 3356\hspace{3mm}5.2 $ty \leftarrow \mbox{MIN}(a.used - 1, ix)$ \\ 3357\hspace{3mm}5.3 $tx \leftarrow ix - ty$ \\ 3358\hspace{3mm}5.4 $iy \leftarrow \mbox{MIN}(a.used - tx, ty + 1)$ \\ 3359\hspace{3mm}5.5 $iy \leftarrow \mbox{MIN}(iy, \lfloor \left (ty - tx + 1 \right )/2 \rfloor)$ \\ 3360\hspace{3mm}5.6 for $iz$ from $0$ to $iz - 1$ do \\ 3361\hspace{6mm}5.6.1 $\_ \hat W \leftarrow \_ \hat W + a_{tx + iz}a_{ty - iz}$ \\ 3362\hspace{3mm}5.7 $\_ \hat W \leftarrow 2 \cdot \_ \hat W + \hat W1$ \\ 3363\hspace{3mm}5.8 if $ix$ is even then \\ 3364\hspace{6mm}5.8.1 $\_ \hat W \leftarrow \_ \hat W + \left ( a_{\lfloor ix/2 \rfloor}\right )^2$ \\ 3365\hspace{3mm}5.9 $W_{ix} \leftarrow \_ \hat W (\mbox{mod }\beta)$ \\ 3366\hspace{3mm}5.10 $\hat W1 \leftarrow \lfloor \_ \hat W / \beta \rfloor$ \\ 3367\\ 33686. $oldused \leftarrow b.used$ \\ 33697. $b.used \leftarrow 2 \cdot a.used$ \\ 33708. for $ix$ from $0$ to $pa - 1$ do \\ 3371\hspace{3mm}8.1 $b_{ix} \leftarrow W_{ix}$ \\ 33729. for $ix$ from $pa$ to $oldused - 1$ do \\ 3373\hspace{3mm}9.1 $b_{ix} \leftarrow 0$ \\ 337410. Clamp excess digits from $b$. (\textit{mp\_clamp}) \\ 337511. Return(\textit{MP\_OKAY}). \\ 3376\hline 3377\end{tabular} 3378\end{center} 3379\end{small} 3380\caption{Algorithm fast\_s\_mp\_sqr} 3381\end{figure} 3382 3383\textbf{Algorithm fast\_s\_mp\_sqr.} 3384This algorithm computes the square of an input using the Comba technique. It is designed to be a replacement for algorithm 3385s\_mp\_sqr when the number of input digits is less than \textbf{MP\_WARRAY} and less than $\delta \over 2$. 3386This algorithm is very similar to the Comba multiplier except with a few key differences we shall make note of. 3387 3388First, we have an accumulator and carry variables $\_ \hat W$ and $\hat W1$ respectively. This is because the inner loop 3389products are to be doubled. If we had added the previous carry in we would be doubling too much. Next we perform an 3390addition MIN condition on $iy$ (step 5.5) to prevent overlapping digits. For example, $a_3 \cdot a_5$ is equal 3391$a_5 \cdot a_3$. Whereas in the multiplication case we would have $5 < a.used$ and $3 \ge 0$ is maintained since we double the sum 3392of the products just outside the inner loop we have to avoid doing this. This is also a good thing since we perform 3393fewer multiplications and the routine ends up being faster. 3394 3395Finally the last difference is the addition of the ``square'' term outside the inner loop (step 5.8). We add in the square 3396only to even outputs and it is the square of the term at the $\lfloor ix / 2 \rfloor$ position. 3397 3398\vspace{+3mm}\begin{small} 3399\hspace{-5.1mm}{\bf File}: bn\_fast\_s\_mp\_sqr.c 3400\vspace{-3mm} 3401\begin{alltt} 3402\end{alltt} 3403\end{small} 3404 3405This implementation is essentially a copy of Comba multiplication with the appropriate changes added to make it faster for 3406the special case of squaring. 3407 3408\subsection{Polynomial Basis Squaring} 3409The same algorithm that performs optimal polynomial basis multiplication can be used to perform polynomial basis squaring. The minor exception 3410is that $\zeta_y = f(y)g(y)$ is actually equivalent to $\zeta_y = f(y)^2$ since $f(y) = g(y)$. Instead of performing $2n + 1$ 3411multiplications to find the $\zeta$ relations, squaring operations are performed instead. 3412 3413\subsection{Karatsuba Squaring} 3414Let $f(x) = ax + b$ represent the polynomial basis representation of a number to square. 3415Let $h(x) = \left ( f(x) \right )^2$ represent the square of the polynomial. The Karatsuba equation can be modified to square a 3416number with the following equation. 3417 3418\begin{equation} 3419h(x) = a^2x^2 + \left ((a + b)^2 - (a^2 + b^2) \right )x + b^2 3420\end{equation} 3421 3422Upon closer inspection this equation only requires the calculation of three half-sized squares: $a^2$, $b^2$ and $(a + b)^2$. As in 3423Karatsuba multiplication, this algorithm can be applied recursively on the input and will achieve an asymptotic running time of 3424$O \left ( n^{lg(3)} \right )$. 3425 3426If the asymptotic times of Karatsuba squaring and multiplication are the same, why not simply use the multiplication algorithm 3427instead? The answer to this arises from the cutoff point for squaring. As in multiplication there exists a cutoff point, at which the 3428time required for a Comba based squaring and a Karatsuba based squaring meet. Due to the overhead inherent in the Karatsuba method, the cutoff 3429point is fairly high. For example, on an AMD Athlon XP processor with $\beta = 2^{28}$, the cutoff point is around 127 digits. 3430 3431Consider squaring a 200 digit number with this technique. It will be split into two 100 digit halves which are subsequently squared. 3432The 100 digit halves will not be squared using Karatsuba, but instead using the faster Comba based squaring algorithm. If Karatsuba multiplication 3433were used instead, the 100 digit numbers would be squared with a slower Comba based multiplication. 3434 3435\newpage\begin{figure}[!here] 3436\begin{small} 3437\begin{center} 3438\begin{tabular}{l} 3439\hline Algorithm \textbf{mp\_karatsuba\_sqr}. \\ 3440\textbf{Input}. mp\_int $a$ \\ 3441\textbf{Output}. $b \leftarrow a^2$ \\ 3442\hline \\ 34431. Initialize the following temporary mp\_ints: $x0$, $x1$, $t1$, $t2$, $x0x0$ and $x1x1$. \\ 34442. If any of the initializations on step 1 failed return(\textit{MP\_MEM}). \\ 3445\\ 3446Split the input. e.g. $a = x1\beta^B + x0$ \\ 34473. $B \leftarrow \lfloor a.used / 2 \rfloor$ \\ 34484. $x0 \leftarrow a \mbox{ (mod }\beta^B\mbox{)}$ (\textit{mp\_mod\_2d}) \\ 34495. $x1 \leftarrow \lfloor a / \beta^B \rfloor$ (\textit{mp\_lshd}) \\ 3450\\ 3451Calculate the three squares. \\ 34526. $x0x0 \leftarrow x0^2$ (\textit{mp\_sqr}) \\ 34537. $x1x1 \leftarrow x1^2$ \\ 34548. $t1 \leftarrow x1 + x0$ (\textit{s\_mp\_add}) \\ 34559. $t1 \leftarrow t1^2$ \\ 3456\\ 3457Compute the middle term. \\ 345810. $t2 \leftarrow x0x0 + x1x1$ (\textit{s\_mp\_add}) \\ 345911. $t1 \leftarrow t1 - t2$ \\ 3460\\ 3461Compute final product. \\ 346212. $t1 \leftarrow t1\beta^B$ (\textit{mp\_lshd}) \\ 346313. $x1x1 \leftarrow x1x1\beta^{2B}$ \\ 346414. $t1 \leftarrow t1 + x0x0$ \\ 346515. $b \leftarrow t1 + x1x1$ \\ 346616. Return(\textit{MP\_OKAY}). \\ 3467\hline 3468\end{tabular} 3469\end{center} 3470\end{small} 3471\caption{Algorithm mp\_karatsuba\_sqr} 3472\end{figure} 3473 3474\textbf{Algorithm mp\_karatsuba\_sqr.} 3475This algorithm computes the square of an input $a$ using the Karatsuba technique. This algorithm is very similar to the Karatsuba based 3476multiplication algorithm with the exception that the three half-size multiplications have been replaced with three half-size squarings. 3477 3478The radix point for squaring is simply placed exactly in the middle of the digits when the input has an odd number of digits, otherwise it is 3479placed just below the middle. Step 3, 4 and 5 compute the two halves required using $B$ 3480as the radix point. The first two squares in steps 6 and 7 are rather straightforward while the last square is of a more compact form. 3481 3482By expanding $\left (x1 + x0 \right )^2$, the $x1^2$ and $x0^2$ terms in the middle disappear, that is $(x0 - x1)^2 - (x1^2 + x0^2) = 2 \cdot x0 \cdot x1$. 3483Now if $5n$ single precision additions and a squaring of $n$-digits is faster than multiplying two $n$-digit numbers and doubling then 3484this method is faster. Assuming no further recursions occur, the difference can be estimated with the following inequality. 3485 3486Let $p$ represent the cost of a single precision addition and $q$ the cost of a single precision multiplication both in terms of time\footnote{Or 3487machine clock cycles.}. 3488 3489\begin{equation} 34905pn +{{q(n^2 + n)} \over 2} \le pn + qn^2 3491\end{equation} 3492 3493For example, on an AMD Athlon XP processor $p = {1 \over 3}$ and $q = 6$. This implies that the following inequality should hold. 3494\begin{center} 3495\begin{tabular}{rcl} 3496${5n \over 3} + 3n^2 + 3n$ & $<$ & ${n \over 3} + 6n^2$ \\ 3497${5 \over 3} + 3n + 3$ & $<$ & ${1 \over 3} + 6n$ \\ 3498${13 \over 9}$ & $<$ & $n$ \\ 3499\end{tabular} 3500\end{center} 3501 3502This results in a cutoff point around $n = 2$. As a consequence it is actually faster to compute the middle term the ``long way'' on processors 3503where multiplication is substantially slower\footnote{On the Athlon there is a 1:17 ratio between clock cycles for addition and multiplication. On 3504the Intel P4 processor this ratio is 1:29 making this method even more beneficial. The only common exception is the ARMv4 processor which has a 3505ratio of 1:7. } than simpler operations such as addition. 3506 3507\vspace{+3mm}\begin{small} 3508\hspace{-5.1mm}{\bf File}: bn\_mp\_karatsuba\_sqr.c 3509\vspace{-3mm} 3510\begin{alltt} 3511\end{alltt} 3512\end{small} 3513 3514This implementation is largely based on the implementation of algorithm mp\_karatsuba\_mul. It uses the same inline style to copy and 3515shift the input into the two halves. The loop from line 54 to line 70 has been modified since only one input exists. The \textbf{used} 3516count of both $x0$ and $x1$ is fixed up and $x0$ is clamped before the calculations begin. At this point $x1$ and $x0$ are valid equivalents 3517to the respective halves as if mp\_rshd and mp\_mod\_2d had been used. 3518 3519By inlining the copy and shift operations the cutoff point for Karatsuba multiplication can be lowered. On the Athlon the cutoff point 3520is exactly at the point where Comba squaring can no longer be used (\textit{128 digits}). On slower processors such as the Intel P4 3521it is actually below the Comba limit (\textit{at 110 digits}). 3522 3523This routine uses the same error trap coding style as mp\_karatsuba\_sqr. As the temporary variables are initialized errors are 3524redirected to the error trap higher up. If the algorithm completes without error the error code is set to \textbf{MP\_OKAY} and 3525mp\_clears are executed normally. 3526 3527\subsection{Toom-Cook Squaring} 3528The Toom-Cook squaring algorithm mp\_toom\_sqr is heavily based on the algorithm mp\_toom\_mul with the exception that squarings are used 3529instead of multiplication to find the five relations. The reader is encouraged to read the description of the latter algorithm and try to 3530derive their own Toom-Cook squaring algorithm. 3531 3532\subsection{High Level Squaring} 3533\newpage\begin{figure}[!here] 3534\begin{small} 3535\begin{center} 3536\begin{tabular}{l} 3537\hline Algorithm \textbf{mp\_sqr}. \\ 3538\textbf{Input}. mp\_int $a$ \\ 3539\textbf{Output}. $b \leftarrow a^2$ \\ 3540\hline \\ 35411. If $a.used \ge TOOM\_SQR\_CUTOFF$ then \\ 3542\hspace{3mm}1.1 $b \leftarrow a^2$ using algorithm mp\_toom\_sqr \\ 35432. else if $a.used \ge KARATSUBA\_SQR\_CUTOFF$ then \\ 3544\hspace{3mm}2.1 $b \leftarrow a^2$ using algorithm mp\_karatsuba\_sqr \\ 35453. else \\ 3546\hspace{3mm}3.1 $digs \leftarrow a.used + b.used + 1$ \\ 3547\hspace{3mm}3.2 If $digs < MP\_ARRAY$ and $a.used \le \delta$ then \\ 3548\hspace{6mm}3.2.1 $b \leftarrow a^2$ using algorithm fast\_s\_mp\_sqr. \\ 3549\hspace{3mm}3.3 else \\ 3550\hspace{6mm}3.3.1 $b \leftarrow a^2$ using algorithm s\_mp\_sqr. \\ 35514. $b.sign \leftarrow MP\_ZPOS$ \\ 35525. Return the result of the unsigned squaring performed. \\ 3553\hline 3554\end{tabular} 3555\end{center} 3556\end{small} 3557\caption{Algorithm mp\_sqr} 3558\end{figure} 3559 3560\textbf{Algorithm mp\_sqr.} 3561This algorithm computes the square of the input using one of four different algorithms. If the input is very large and has at least 3562\textbf{TOOM\_SQR\_CUTOFF} or \textbf{KARATSUBA\_SQR\_CUTOFF} digits then either the Toom-Cook or the Karatsuba Squaring algorithm is used. If 3563neither of the polynomial basis algorithms should be used then either the Comba or baseline algorithm is used. 3564 3565\vspace{+3mm}\begin{small} 3566\hspace{-5.1mm}{\bf File}: bn\_mp\_sqr.c 3567\vspace{-3mm} 3568\begin{alltt} 3569\end{alltt} 3570\end{small} 3571 3572\section*{Exercises} 3573\begin{tabular}{cl} 3574$\left [ 3 \right ] $ & Devise an efficient algorithm for selection of the radix point to handle inputs \\ 3575 & that have different number of digits in Karatsuba multiplication. \\ 3576 & \\ 3577$\left [ 2 \right ] $ & In section 5.3 the fact that every column of a squaring is made up \\ 3578 & of double products and at most one square is stated. Prove this statement. \\ 3579 & \\ 3580$\left [ 3 \right ] $ & Prove the equation for Karatsuba squaring. \\ 3581 & \\ 3582$\left [ 1 \right ] $ & Prove that Karatsuba squaring requires $O \left (n^{lg(3)} \right )$ time. \\ 3583 & \\ 3584$\left [ 2 \right ] $ & Determine the minimal ratio between addition and multiplication clock cycles \\ 3585 & required for equation $6.7$ to be true. \\ 3586 & \\ 3587$\left [ 3 \right ] $ & Implement a threaded version of Comba multiplication (and squaring) where you \\ 3588 & compute subsets of the columns in each thread. Determine a cutoff point where \\ 3589 & it is effective and add the logic to mp\_mul() and mp\_sqr(). \\ 3590 &\\ 3591$\left [ 4 \right ] $ & Same as the previous but also modify the Karatsuba and Toom-Cook. You must \\ 3592 & increase the throughput of mp\_exptmod() for random odd moduli in the range \\ 3593 & $512 \ldots 4096$ bits significantly ($> 2x$) to complete this challenge. \\ 3594 & \\ 3595\end{tabular} 3596 3597\chapter{Modular Reduction} 3598\section{Basics of Modular Reduction} 3599\index{modular residue} 3600Modular reduction is an operation that arises quite often within public key cryptography algorithms and various number theoretic algorithms, 3601such as factoring. Modular reduction algorithms are the third class of algorithms of the ``multipliers'' set. A number $a$ is said to be \textit{reduced} 3602modulo another number $b$ by finding the remainder of the division $a/b$. Full integer division with remainder is a topic to be covered 3603in~\ref{sec:division}. 3604 3605Modular reduction is equivalent to solving for $r$ in the following equation. $a = bq + r$ where $q = \lfloor a/b \rfloor$. The result 3606$r$ is said to be ``congruent to $a$ modulo $b$'' which is also written as $r \equiv a \mbox{ (mod }b\mbox{)}$. In other vernacular $r$ is known as the 3607``modular residue'' which leads to ``quadratic residue''\footnote{That's fancy talk for $b \equiv a^2 \mbox{ (mod }p\mbox{)}$.} and 3608other forms of residues. 3609 3610Modular reductions are normally used to create either finite groups, rings or fields. The most common usage for performance driven modular reductions 3611is in modular exponentiation algorithms. That is to compute $d = a^b \mbox{ (mod }c\mbox{)}$ as fast as possible. This operation is used in the 3612RSA and Diffie-Hellman public key algorithms, for example. Modular multiplication and squaring also appears as a fundamental operation in 3613elliptic curve cryptographic algorithms. As will be discussed in the subsequent chapter there exist fast algorithms for computing modular 3614exponentiations without having to perform (\textit{in this example}) $b - 1$ multiplications. These algorithms will produce partial results in the 3615range $0 \le x < c^2$ which can be taken advantage of to create several efficient algorithms. They have also been used to create redundancy check 3616algorithms known as CRCs, error correction codes such as Reed-Solomon and solve a variety of number theoeretic problems. 3617 3618\section{The Barrett Reduction} 3619The Barrett reduction algorithm \cite{BARRETT} was inspired by fast division algorithms which multiply by the reciprocal to emulate 3620division. Barretts observation was that the residue $c$ of $a$ modulo $b$ is equal to 3621 3622\begin{equation} 3623c = a - b \cdot \lfloor a/b \rfloor 3624\end{equation} 3625 3626Since algorithms such as modular exponentiation would be using the same modulus extensively, typical DSP\footnote{It is worth noting that Barrett's paper 3627targeted the DSP56K processor.} intuition would indicate the next step would be to replace $a/b$ by a multiplication by the reciprocal. However, 3628DSP intuition on its own will not work as these numbers are considerably larger than the precision of common DSP floating point data types. 3629It would take another common optimization to optimize the algorithm. 3630 3631\subsection{Fixed Point Arithmetic} 3632The trick used to optimize the above equation is based on a technique of emulating floating point data types with fixed precision integers. Fixed 3633point arithmetic would become very popular as it greatly optimize the ``3d-shooter'' genre of games in the mid 1990s when floating point units were 3634fairly slow if not unavailable. The idea behind fixed point arithmetic is to take a normal $k$-bit integer data type and break it into $p$-bit 3635integer and a $q$-bit fraction part (\textit{where $p+q = k$}). 3636 3637In this system a $k$-bit integer $n$ would actually represent $n/2^q$. For example, with $q = 4$ the integer $n = 37$ would actually represent the 3638value $2.3125$. To multiply two fixed point numbers the integers are multiplied using traditional arithmetic and subsequently normalized by 3639moving the implied decimal point back to where it should be. For example, with $q = 4$ to multiply the integers $9$ and $5$ they must be converted 3640to fixed point first by multiplying by $2^q$. Let $a = 9(2^q)$ represent the fixed point representation of $9$ and $b = 5(2^q)$ represent the 3641fixed point representation of $5$. The product $ab$ is equal to $45(2^{2q})$ which when normalized by dividing by $2^q$ produces $45(2^q)$. 3642 3643This technique became popular since a normal integer multiplication and logical shift right are the only required operations to perform a multiplication 3644of two fixed point numbers. Using fixed point arithmetic, division can be easily approximated by multiplying by the reciprocal. If $2^q$ is 3645equivalent to one than $2^q/b$ is equivalent to the fixed point approximation of $1/b$ using real arithmetic. Using this fact dividing an integer 3646$a$ by another integer $b$ can be achieved with the following expression. 3647 3648\begin{equation} 3649\lfloor a / b \rfloor \mbox{ }\approx\mbox{ } \lfloor (a \cdot \lfloor 2^q / b \rfloor)/2^q \rfloor 3650\end{equation} 3651 3652The precision of the division is proportional to the value of $q$. If the divisor $b$ is used frequently as is the case with 3653modular exponentiation pre-computing $2^q/b$ will allow a division to be performed with a multiplication and a right shift. Both operations 3654are considerably faster than division on most processors. 3655 3656Consider dividing $19$ by $5$. The correct result is $\lfloor 19/5 \rfloor = 3$. With $q = 3$ the reciprocal is $\lfloor 2^q/5 \rfloor = 1$ which 3657leads to a product of $19$ which when divided by $2^q$ produces $2$. However, with $q = 4$ the reciprocal is $\lfloor 2^q/5 \rfloor = 3$ and 3658the result of the emulated division is $\lfloor 3 \cdot 19 / 2^q \rfloor = 3$ which is correct. The value of $2^q$ must be close to or ideally 3659larger than the dividend. In effect if $a$ is the dividend then $q$ should allow $0 \le \lfloor a/2^q \rfloor \le 1$ in order for this approach 3660to work correctly. Plugging this form of divison into the original equation the following modular residue equation arises. 3661 3662\begin{equation} 3663c = a - b \cdot \lfloor (a \cdot \lfloor 2^q / b \rfloor)/2^q \rfloor 3664\end{equation} 3665 3666Using the notation from \cite{BARRETT} the value of $\lfloor 2^q / b \rfloor$ will be represented by the $\mu$ symbol. Using the $\mu$ 3667variable also helps re-inforce the idea that it is meant to be computed once and re-used. 3668 3669\begin{equation} 3670c = a - b \cdot \lfloor (a \cdot \mu)/2^q \rfloor 3671\end{equation} 3672 3673Provided that $2^q \ge a$ this algorithm will produce a quotient that is either exactly correct or off by a value of one. In the context of Barrett 3674reduction the value of $a$ is bound by $0 \le a \le (b - 1)^2$ meaning that $2^q \ge b^2$ is sufficient to ensure the reciprocal will have enough 3675precision. 3676 3677Let $n$ represent the number of digits in $b$. This algorithm requires approximately $2n^2$ single precision multiplications to produce the quotient and 3678another $n^2$ single precision multiplications to find the residue. In total $3n^2$ single precision multiplications are required to 3679reduce the number. 3680 3681For example, if $b = 1179677$ and $q = 41$ ($2^q > b^2$), then the reciprocal $\mu$ is equal to $\lfloor 2^q / b \rfloor = 1864089$. Consider reducing 3682$a = 180388626447$ modulo $b$ using the above reduction equation. The quotient using the new formula is $\lfloor (a \cdot \mu) / 2^q \rfloor = 152913$. 3683By subtracting $152913b$ from $a$ the correct residue $a \equiv 677346 \mbox{ (mod }b\mbox{)}$ is found. 3684 3685\subsection{Choosing a Radix Point} 3686Using the fixed point representation a modular reduction can be performed with $3n^2$ single precision multiplications. If that were the best 3687that could be achieved a full division\footnote{A division requires approximately $O(2cn^2)$ single precision multiplications for a small value of $c$. 3688See~\ref{sec:division} for further details.} might as well be used in its place. The key to optimizing the reduction is to reduce the precision of 3689the initial multiplication that finds the quotient. 3690 3691Let $a$ represent the number of which the residue is sought. Let $b$ represent the modulus used to find the residue. Let $m$ represent 3692the number of digits in $b$. For the purposes of this discussion we will assume that the number of digits in $a$ is $2m$, which is generally true if 3693two $m$-digit numbers have been multiplied. Dividing $a$ by $b$ is the same as dividing a $2m$ digit integer by a $m$ digit integer. Digits below the 3694$m - 1$'th digit of $a$ will contribute at most a value of $1$ to the quotient because $\beta^k < b$ for any $0 \le k \le m - 1$. Another way to 3695express this is by re-writing $a$ as two parts. If $a' \equiv a \mbox{ (mod }b^m\mbox{)}$ and $a'' = a - a'$ then 3696${a \over b} \equiv {{a' + a''} \over b}$ which is equivalent to ${a' \over b} + {a'' \over b}$. Since $a'$ is bound to be less than $b$ the quotient 3697is bound by $0 \le {a' \over b} < 1$. 3698 3699Since the digits of $a'$ do not contribute much to the quotient the observation is that they might as well be zero. However, if the digits 3700``might as well be zero'' they might as well not be there in the first place. Let $q_0 = \lfloor a/\beta^{m-1} \rfloor$ represent the input 3701with the irrelevant digits trimmed. Now the modular reduction is trimmed to the almost equivalent equation 3702 3703\begin{equation} 3704c = a - b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor 3705\end{equation} 3706 3707Note that the original divisor $2^q$ has been replaced with $\beta^{m+1}$ where in this case $q$ is a multiple of $lg(\beta)$. Also note that the 3708exponent on the divisor when added to the amount $q_0$ was shifted by equals $2m$. If the optimization had not been performed the divisor 3709would have the exponent $2m$ so in the end the exponents do ``add up''. Using the above equation the quotient 3710$\lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor$ can be off from the true quotient by at most two. The original fixed point quotient can be off 3711by as much as one (\textit{provided the radix point is chosen suitably}) and now that the lower irrelevent digits have been trimmed the quotient 3712can be off by an additional value of one for a total of at most two. This implies that 3713$0 \le a - b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor < 3b$. By first subtracting $b$ times the quotient and then conditionally subtracting 3714$b$ once or twice the residue is found. 3715 3716The quotient is now found using $(m + 1)(m) = m^2 + m$ single precision multiplications and the residue with an additional $m^2$ single 3717precision multiplications, ignoring the subtractions required. In total $2m^2 + m$ single precision multiplications are required to find the residue. 3718This is considerably faster than the original attempt. 3719 3720For example, let $\beta = 10$ represent the radix of the digits. Let $b = 9999$ represent the modulus which implies $m = 4$. Let $a = 99929878$ 3721represent the value of which the residue is desired. In this case $q = 8$ since $10^7 < 9999^2$ meaning that $\mu = \lfloor \beta^{q}/b \rfloor = 10001$. 3722With the new observation the multiplicand for the quotient is equal to $q_0 = \lfloor a / \beta^{m - 1} \rfloor = 99929$. The quotient is then 3723$\lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor = 9993$. Subtracting $9993b$ from $a$ and the correct residue $a \equiv 9871 \mbox{ (mod }b\mbox{)}$ 3724is found. 3725 3726\subsection{Trimming the Quotient} 3727So far the reduction algorithm has been optimized from $3m^2$ single precision multiplications down to $2m^2 + m$ single precision multiplications. As 3728it stands now the algorithm is already fairly fast compared to a full integer division algorithm. However, there is still room for 3729optimization. 3730 3731After the first multiplication inside the quotient ($q_0 \cdot \mu$) the value is shifted right by $m + 1$ places effectively nullifying the lower 3732half of the product. It would be nice to be able to remove those digits from the product to effectively cut down the number of single precision 3733multiplications. If the number of digits in the modulus $m$ is far less than $\beta$ a full product is not required for the algorithm to work properly. 3734In fact the lower $m - 2$ digits will not affect the upper half of the product at all and do not need to be computed. 3735 3736The value of $\mu$ is a $m$-digit number and $q_0$ is a $m + 1$ digit number. Using a full multiplier $(m + 1)(m) = m^2 + m$ single precision 3737multiplications would be required. Using a multiplier that will only produce digits at and above the $m - 1$'th digit reduces the number 3738of single precision multiplications to ${m^2 + m} \over 2$ single precision multiplications. 3739 3740\subsection{Trimming the Residue} 3741After the quotient has been calculated it is used to reduce the input. As previously noted the algorithm is not exact and it can be off by a small 3742multiple of the modulus, that is $0 \le a - b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor < 3b$. If $b$ is $m$ digits than the 3743result of reduction equation is a value of at most $m + 1$ digits (\textit{provided $3 < \beta$}) implying that the upper $m - 1$ digits are 3744implicitly zero. 3745 3746The next optimization arises from this very fact. Instead of computing $b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor$ using a full 3747$O(m^2)$ multiplication algorithm only the lower $m+1$ digits of the product have to be computed. Similarly the value of $a$ can 3748be reduced modulo $\beta^{m+1}$ before the multiple of $b$ is subtracted which simplifes the subtraction as well. A multiplication that produces 3749only the lower $m+1$ digits requires ${m^2 + 3m - 2} \over 2$ single precision multiplications. 3750 3751With both optimizations in place the algorithm is the algorithm Barrett proposed. It requires $m^2 + 2m - 1$ single precision multiplications which 3752is considerably faster than the straightforward $3m^2$ method. 3753 3754\subsection{The Barrett Algorithm} 3755\newpage\begin{figure}[!here] 3756\begin{small} 3757\begin{center} 3758\begin{tabular}{l} 3759\hline Algorithm \textbf{mp\_reduce}. \\ 3760\textbf{Input}. mp\_int $a$, mp\_int $b$ and $\mu = \lfloor \beta^{2m}/b \rfloor, m = \lceil lg_{\beta}(b) \rceil, (0 \le a < b^2, b > 1)$ \\ 3761\textbf{Output}. $a \mbox{ (mod }b\mbox{)}$ \\ 3762\hline \\ 3763Let $m$ represent the number of digits in $b$. \\ 37641. Make a copy of $a$ and store it in $q$. (\textit{mp\_init\_copy}) \\ 37652. $q \leftarrow \lfloor q / \beta^{m - 1} \rfloor$ (\textit{mp\_rshd}) \\ 3766\\ 3767Produce the quotient. \\ 37683. $q \leftarrow q \cdot \mu$ (\textit{note: only produce digits at or above $m-1$}) \\ 37694. $q \leftarrow \lfloor q / \beta^{m + 1} \rfloor$ \\ 3770\\ 3771Subtract the multiple of modulus from the input. \\ 37725. $a \leftarrow a \mbox{ (mod }\beta^{m+1}\mbox{)}$ (\textit{mp\_mod\_2d}) \\ 37736. $q \leftarrow q \cdot b \mbox{ (mod }\beta^{m+1}\mbox{)}$ (\textit{s\_mp\_mul\_digs}) \\ 37747. $a \leftarrow a - q$ (\textit{mp\_sub}) \\ 3775\\ 3776Add $\beta^{m+1}$ if a carry occured. \\ 37778. If $a < 0$ then (\textit{mp\_cmp\_d}) \\ 3778\hspace{3mm}8.1 $q \leftarrow 1$ (\textit{mp\_set}) \\ 3779\hspace{3mm}8.2 $q \leftarrow q \cdot \beta^{m+1}$ (\textit{mp\_lshd}) \\ 3780\hspace{3mm}8.3 $a \leftarrow a + q$ \\ 3781\\ 3782Now subtract the modulus if the residue is too large (e.g. quotient too small). \\ 37839. While $a \ge b$ do (\textit{mp\_cmp}) \\ 3784\hspace{3mm}9.1 $c \leftarrow a - b$ \\ 378510. Clear $q$. \\ 378611. Return(\textit{MP\_OKAY}) \\ 3787\hline 3788\end{tabular} 3789\end{center} 3790\end{small} 3791\caption{Algorithm mp\_reduce} 3792\end{figure} 3793 3794\textbf{Algorithm mp\_reduce.} 3795This algorithm will reduce the input $a$ modulo $b$ in place using the Barrett algorithm. It is loosely based on algorithm 14.42 of HAC 3796\cite[pp. 602]{HAC} which is based on the paper from Paul Barrett \cite{BARRETT}. The algorithm has several restrictions and assumptions which must 3797be adhered to for the algorithm to work. 3798 3799First the modulus $b$ is assumed to be positive and greater than one. If the modulus were less than or equal to one than subtracting 3800a multiple of it would either accomplish nothing or actually enlarge the input. The input $a$ must be in the range $0 \le a < b^2$ in order 3801for the quotient to have enough precision. If $a$ is the product of two numbers that were already reduced modulo $b$, this will not be a problem. 3802Technically the algorithm will still work if $a \ge b^2$ but it will take much longer to finish. The value of $\mu$ is passed as an argument to this 3803algorithm and is assumed to be calculated and stored before the algorithm is used. 3804 3805Recall that the multiplication for the quotient on step 3 must only produce digits at or above the $m-1$'th position. An algorithm called 3806$s\_mp\_mul\_high\_digs$ which has not been presented is used to accomplish this task. The algorithm is based on $s\_mp\_mul\_digs$ except that 3807instead of stopping at a given level of precision it starts at a given level of precision. This optimal algorithm can only be used if the number 3808of digits in $b$ is very much smaller than $\beta$. 3809 3810While it is known that 3811$a \ge b \cdot \lfloor (q_0 \cdot \mu) / \beta^{m+1} \rfloor$ only the lower $m+1$ digits are being used to compute the residue, so an implied 3812``borrow'' from the higher digits might leave a negative result. After the multiple of the modulus has been subtracted from $a$ the residue must be 3813fixed up in case it is negative. The invariant $\beta^{m+1}$ must be added to the residue to make it positive again. 3814 3815The while loop at step 9 will subtract $b$ until the residue is less than $b$. If the algorithm is performed correctly this step is 3816performed at most twice, and on average once. However, if $a \ge b^2$ than it will iterate substantially more times than it should. 3817 3818\vspace{+3mm}\begin{small} 3819\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce.c 3820\vspace{-3mm} 3821\begin{alltt} 3822\end{alltt} 3823\end{small} 3824 3825The first multiplication that determines the quotient can be performed by only producing the digits from $m - 1$ and up. This essentially halves 3826the number of single precision multiplications required. However, the optimization is only safe if $\beta$ is much larger than the number of digits 3827in the modulus. In the source code this is evaluated on lines 36 to 44 where algorithm s\_mp\_mul\_high\_digs is used when it is 3828safe to do so. 3829 3830\subsection{The Barrett Setup Algorithm} 3831In order to use algorithm mp\_reduce the value of $\mu$ must be calculated in advance. Ideally this value should be computed once and stored for 3832future use so that the Barrett algorithm can be used without delay. 3833 3834\newpage\begin{figure}[!here] 3835\begin{small} 3836\begin{center} 3837\begin{tabular}{l} 3838\hline Algorithm \textbf{mp\_reduce\_setup}. \\ 3839\textbf{Input}. mp\_int $a$ ($a > 1$) \\ 3840\textbf{Output}. $\mu \leftarrow \lfloor \beta^{2m}/a \rfloor$ \\ 3841\hline \\ 38421. $\mu \leftarrow 2^{2 \cdot lg(\beta) \cdot m}$ (\textit{mp\_2expt}) \\ 38432. $\mu \leftarrow \lfloor \mu / b \rfloor$ (\textit{mp\_div}) \\ 38443. Return(\textit{MP\_OKAY}) \\ 3845\hline 3846\end{tabular} 3847\end{center} 3848\end{small} 3849\caption{Algorithm mp\_reduce\_setup} 3850\end{figure} 3851 3852\textbf{Algorithm mp\_reduce\_setup.} 3853This algorithm computes the reciprocal $\mu$ required for Barrett reduction. First $\beta^{2m}$ is calculated as $2^{2 \cdot lg(\beta) \cdot m}$ which 3854is equivalent and much faster. The final value is computed by taking the integer quotient of $\lfloor \mu / b \rfloor$. 3855 3856\vspace{+3mm}\begin{small} 3857\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce\_setup.c 3858\vspace{-3mm} 3859\begin{alltt} 3860\end{alltt} 3861\end{small} 3862 3863This simple routine calculates the reciprocal $\mu$ required by Barrett reduction. Note the extended usage of algorithm mp\_div where the variable 3864which would received the remainder is passed as NULL. As will be discussed in~\ref{sec:division} the division routine allows both the quotient and the 3865remainder to be passed as NULL meaning to ignore the value. 3866 3867\section{The Montgomery Reduction} 3868Montgomery reduction\footnote{Thanks to Niels Ferguson for his insightful explanation of the algorithm.} \cite{MONT} is by far the most interesting 3869form of reduction in common use. It computes a modular residue which is not actually equal to the residue of the input yet instead equal to a 3870residue times a constant. However, as perplexing as this may sound the algorithm is relatively simple and very efficient. 3871 3872Throughout this entire section the variable $n$ will represent the modulus used to form the residue. As will be discussed shortly the value of 3873$n$ must be odd. The variable $x$ will represent the quantity of which the residue is sought. Similar to the Barrett algorithm the input 3874is restricted to $0 \le x < n^2$. To begin the description some simple number theory facts must be established. 3875 3876\textbf{Fact 1.} Adding $n$ to $x$ does not change the residue since in effect it adds one to the quotient $\lfloor x / n \rfloor$. Another way 3877to explain this is that $n$ is (\textit{or multiples of $n$ are}) congruent to zero modulo $n$. Adding zero will not change the value of the residue. 3878 3879\textbf{Fact 2.} If $x$ is even then performing a division by two in $\Z$ is congruent to $x \cdot 2^{-1} \mbox{ (mod }n\mbox{)}$. Actually 3880this is an application of the fact that if $x$ is evenly divisible by any $k \in \Z$ then division in $\Z$ will be congruent to 3881multiplication by $k^{-1}$ modulo $n$. 3882 3883From these two simple facts the following simple algorithm can be derived. 3884 3885\newpage\begin{figure}[!here] 3886\begin{small} 3887\begin{center} 3888\begin{tabular}{l} 3889\hline Algorithm \textbf{Montgomery Reduction}. \\ 3890\textbf{Input}. Integer $x$, $n$ and $k$ \\ 3891\textbf{Output}. $2^{-k}x \mbox{ (mod }n\mbox{)}$ \\ 3892\hline \\ 38931. for $t$ from $1$ to $k$ do \\ 3894\hspace{3mm}1.1 If $x$ is odd then \\ 3895\hspace{6mm}1.1.1 $x \leftarrow x + n$ \\ 3896\hspace{3mm}1.2 $x \leftarrow x/2$ \\ 38972. Return $x$. \\ 3898\hline 3899\end{tabular} 3900\end{center} 3901\end{small} 3902\caption{Algorithm Montgomery Reduction} 3903\end{figure} 3904 3905The algorithm reduces the input one bit at a time using the two congruencies stated previously. Inside the loop $n$, which is odd, is 3906added to $x$ if $x$ is odd. This forces $x$ to be even which allows the division by two in $\Z$ to be congruent to a modular division by two. Since 3907$x$ is assumed to be initially much larger than $n$ the addition of $n$ will contribute an insignificant magnitude to $x$. Let $r$ represent the 3908final result of the Montgomery algorithm. If $k > lg(n)$ and $0 \le x < n^2$ then the final result is limited to 3909$0 \le r < \lfloor x/2^k \rfloor + n$. As a result at most a single subtraction is required to get the residue desired. 3910 3911\begin{figure}[here] 3912\begin{small} 3913\begin{center} 3914\begin{tabular}{|c|l|} 3915\hline \textbf{Step number ($t$)} & \textbf{Result ($x$)} \\ 3916\hline $1$ & $x + n = 5812$, $x/2 = 2906$ \\ 3917\hline $2$ & $x/2 = 1453$ \\ 3918\hline $3$ & $x + n = 1710$, $x/2 = 855$ \\ 3919\hline $4$ & $x + n = 1112$, $x/2 = 556$ \\ 3920\hline $5$ & $x/2 = 278$ \\ 3921\hline $6$ & $x/2 = 139$ \\ 3922\hline $7$ & $x + n = 396$, $x/2 = 198$ \\ 3923\hline $8$ & $x/2 = 99$ \\ 3924\hline $9$ & $x + n = 356$, $x/2 = 178$ \\ 3925\hline 3926\end{tabular} 3927\end{center} 3928\end{small} 3929\caption{Example of Montgomery Reduction (I)} 3930\label{fig:MONT1} 3931\end{figure} 3932 3933Consider the example in figure~\ref{fig:MONT1} which reduces $x = 5555$ modulo $n = 257$ when $k = 9$ (note $\beta^k = 512$ which is larger than $n$). The result of 3934the algorithm $r = 178$ is congruent to the value of $2^{-9} \cdot 5555 \mbox{ (mod }257\mbox{)}$. When $r$ is multiplied by $2^9$ modulo $257$ the correct residue 3935$r \equiv 158$ is produced. 3936 3937Let $k = \lfloor lg(n) \rfloor + 1$ represent the number of bits in $n$. The current algorithm requires $2k^2$ single precision shifts 3938and $k^2$ single precision additions. At this rate the algorithm is most certainly slower than Barrett reduction and not terribly useful. 3939Fortunately there exists an alternative representation of the algorithm. 3940 3941\begin{figure}[!here] 3942\begin{small} 3943\begin{center} 3944\begin{tabular}{l} 3945\hline Algorithm \textbf{Montgomery Reduction} (modified I). \\ 3946\textbf{Input}. Integer $x$, $n$ and $k$ ($2^k > n$) \\ 3947\textbf{Output}. $2^{-k}x \mbox{ (mod }n\mbox{)}$ \\ 3948\hline \\ 39491. for $t$ from $1$ to $k$ do \\ 3950\hspace{3mm}1.1 If the $t$'th bit of $x$ is one then \\ 3951\hspace{6mm}1.1.1 $x \leftarrow x + 2^tn$ \\ 39522. Return $x/2^k$. \\ 3953\hline 3954\end{tabular} 3955\end{center} 3956\end{small} 3957\caption{Algorithm Montgomery Reduction (modified I)} 3958\end{figure} 3959 3960This algorithm is equivalent since $2^tn$ is a multiple of $n$ and the lower $k$ bits of $x$ are zero by step 2. The number of single 3961precision shifts has now been reduced from $2k^2$ to $k^2 + k$ which is only a small improvement. 3962 3963\begin{figure}[here] 3964\begin{small} 3965\begin{center} 3966\begin{tabular}{|c|l|r|} 3967\hline \textbf{Step number ($t$)} & \textbf{Result ($x$)} & \textbf{Result ($x$) in Binary} \\ 3968\hline -- & $5555$ & $1010110110011$ \\ 3969\hline $1$ & $x + 2^{0}n = 5812$ & $1011010110100$ \\ 3970\hline $2$ & $5812$ & $1011010110100$ \\ 3971\hline $3$ & $x + 2^{2}n = 6840$ & $1101010111000$ \\ 3972\hline $4$ & $x + 2^{3}n = 8896$ & $10001011000000$ \\ 3973\hline $5$ & $8896$ & $10001011000000$ \\ 3974\hline $6$ & $8896$ & $10001011000000$ \\ 3975\hline $7$ & $x + 2^{6}n = 25344$ & $110001100000000$ \\ 3976\hline $8$ & $25344$ & $110001100000000$ \\ 3977\hline $9$ & $x + 2^{7}n = 91136$ & $10110010000000000$ \\ 3978\hline -- & $x/2^k = 178$ & \\ 3979\hline 3980\end{tabular} 3981\end{center} 3982\end{small} 3983\caption{Example of Montgomery Reduction (II)} 3984\label{fig:MONT2} 3985\end{figure} 3986 3987Figure~\ref{fig:MONT2} demonstrates the modified algorithm reducing $x = 5555$ modulo $n = 257$ with $k = 9$. 3988With this algorithm a single shift right at the end is the only right shift required to reduce the input instead of $k$ right shifts inside the 3989loop. Note that for the iterations $t = 2, 5, 6$ and $8$ where the result $x$ is not changed. In those iterations the $t$'th bit of $x$ is 3990zero and the appropriate multiple of $n$ does not need to be added to force the $t$'th bit of the result to zero. 3991 3992\subsection{Digit Based Montgomery Reduction} 3993Instead of computing the reduction on a bit-by-bit basis it is actually much faster to compute it on digit-by-digit basis. Consider the 3994previous algorithm re-written to compute the Montgomery reduction in this new fashion. 3995 3996\begin{figure}[!here] 3997\begin{small} 3998\begin{center} 3999\begin{tabular}{l} 4000\hline Algorithm \textbf{Montgomery Reduction} (modified II). \\ 4001\textbf{Input}. Integer $x$, $n$ and $k$ ($\beta^k > n$) \\ 4002\textbf{Output}. $\beta^{-k}x \mbox{ (mod }n\mbox{)}$ \\ 4003\hline \\ 40041. for $t$ from $0$ to $k - 1$ do \\ 4005\hspace{3mm}1.1 $x \leftarrow x + \mu n \beta^t$ \\ 40062. Return $x/\beta^k$. \\ 4007\hline 4008\end{tabular} 4009\end{center} 4010\end{small} 4011\caption{Algorithm Montgomery Reduction (modified II)} 4012\end{figure} 4013 4014The value $\mu n \beta^t$ is a multiple of the modulus $n$ meaning that it will not change the residue. If the first digit of 4015the value $\mu n \beta^t$ equals the negative (modulo $\beta$) of the $t$'th digit of $x$ then the addition will result in a zero digit. This 4016problem breaks down to solving the following congruency. 4017 4018\begin{center} 4019\begin{tabular}{rcl} 4020$x_t + \mu n_0$ & $\equiv$ & $0 \mbox{ (mod }\beta\mbox{)}$ \\ 4021$\mu n_0$ & $\equiv$ & $-x_t \mbox{ (mod }\beta\mbox{)}$ \\ 4022$\mu$ & $\equiv$ & $-x_t/n_0 \mbox{ (mod }\beta\mbox{)}$ \\ 4023\end{tabular} 4024\end{center} 4025 4026In each iteration of the loop on step 1 a new value of $\mu$ must be calculated. The value of $-1/n_0 \mbox{ (mod }\beta\mbox{)}$ is used 4027extensively in this algorithm and should be precomputed. Let $\rho$ represent the negative of the modular inverse of $n_0$ modulo $\beta$. 4028 4029For example, let $\beta = 10$ represent the radix. Let $n = 17$ represent the modulus which implies $k = 2$ and $\rho \equiv 7$. Let $x = 33$ 4030represent the value to reduce. 4031 4032\newpage\begin{figure} 4033\begin{center} 4034\begin{tabular}{|c|c|c|} 4035\hline \textbf{Step ($t$)} & \textbf{Value of $x$} & \textbf{Value of $\mu$} \\ 4036\hline -- & $33$ & --\\ 4037\hline $0$ & $33 + \mu n = 50$ & $1$ \\ 4038\hline $1$ & $50 + \mu n \beta = 900$ & $5$ \\ 4039\hline 4040\end{tabular} 4041\end{center} 4042\caption{Example of Montgomery Reduction} 4043\end{figure} 4044 4045The final result $900$ is then divided by $\beta^k$ to produce the final result $9$. The first observation is that $9 \nequiv x \mbox{ (mod }n\mbox{)}$ 4046which implies the result is not the modular residue of $x$ modulo $n$. However, recall that the residue is actually multiplied by $\beta^{-k}$ in 4047the algorithm. To get the true residue the value must be multiplied by $\beta^k$. In this case $\beta^k \equiv 15 \mbox{ (mod }n\mbox{)}$ and 4048the correct residue is $9 \cdot 15 \equiv 16 \mbox{ (mod }n\mbox{)}$. 4049 4050\subsection{Baseline Montgomery Reduction} 4051The baseline Montgomery reduction algorithm will produce the residue for any size input. It is designed to be a catch-all algororithm for 4052Montgomery reductions. 4053 4054\newpage\begin{figure}[!here] 4055\begin{small} 4056\begin{center} 4057\begin{tabular}{l} 4058\hline Algorithm \textbf{mp\_montgomery\_reduce}. \\ 4059\textbf{Input}. mp\_int $x$, mp\_int $n$ and a digit $\rho \equiv -1/n_0 \mbox{ (mod }n\mbox{)}$. \\ 4060\hspace{11.5mm}($0 \le x < n^2, n > 1, (n, \beta) = 1, \beta^k > n$) \\ 4061\textbf{Output}. $\beta^{-k}x \mbox{ (mod }n\mbox{)}$ \\ 4062\hline \\ 40631. $digs \leftarrow 2n.used + 1$ \\ 40642. If $digs < MP\_ARRAY$ and $m.used < \delta$ then \\ 4065\hspace{3mm}2.1 Use algorithm fast\_mp\_montgomery\_reduce instead. \\ 4066\\ 4067Setup $x$ for the reduction. \\ 40683. If $x.alloc < digs$ then grow $x$ to $digs$ digits. \\ 40694. $x.used \leftarrow digs$ \\ 4070\\ 4071Eliminate the lower $k$ digits. \\ 40725. For $ix$ from $0$ to $k - 1$ do \\ 4073\hspace{3mm}5.1 $\mu \leftarrow x_{ix} \cdot \rho \mbox{ (mod }\beta\mbox{)}$ \\ 4074\hspace{3mm}5.2 $u \leftarrow 0$ \\ 4075\hspace{3mm}5.3 For $iy$ from $0$ to $k - 1$ do \\ 4076\hspace{6mm}5.3.1 $\hat r \leftarrow \mu n_{iy} + x_{ix + iy} + u$ \\ 4077\hspace{6mm}5.3.2 $x_{ix + iy} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\ 4078\hspace{6mm}5.3.3 $u \leftarrow \lfloor \hat r / \beta \rfloor$ \\ 4079\hspace{3mm}5.4 While $u > 0$ do \\ 4080\hspace{6mm}5.4.1 $iy \leftarrow iy + 1$ \\ 4081\hspace{6mm}5.4.2 $x_{ix + iy} \leftarrow x_{ix + iy} + u$ \\ 4082\hspace{6mm}5.4.3 $u \leftarrow \lfloor x_{ix+iy} / \beta \rfloor$ \\ 4083\hspace{6mm}5.4.4 $x_{ix + iy} \leftarrow x_{ix+iy} \mbox{ (mod }\beta\mbox{)}$ \\ 4084\\ 4085Divide by $\beta^k$ and fix up as required. \\ 40866. $x \leftarrow \lfloor x / \beta^k \rfloor$ \\ 40877. If $x \ge n$ then \\ 4088\hspace{3mm}7.1 $x \leftarrow x - n$ \\ 40898. Return(\textit{MP\_OKAY}). \\ 4090\hline 4091\end{tabular} 4092\end{center} 4093\end{small} 4094\caption{Algorithm mp\_montgomery\_reduce} 4095\end{figure} 4096 4097\textbf{Algorithm mp\_montgomery\_reduce.} 4098This algorithm reduces the input $x$ modulo $n$ in place using the Montgomery reduction algorithm. The algorithm is loosely based 4099on algorithm 14.32 of \cite[pp.601]{HAC} except it merges the multiplication of $\mu n \beta^t$ with the addition in the inner loop. The 4100restrictions on this algorithm are fairly easy to adapt to. First $0 \le x < n^2$ bounds the input to numbers in the same range as 4101for the Barrett algorithm. Additionally if $n > 1$ and $n$ is odd there will exist a modular inverse $\rho$. $\rho$ must be calculated in 4102advance of this algorithm. Finally the variable $k$ is fixed and a pseudonym for $n.used$. 4103 4104Step 2 decides whether a faster Montgomery algorithm can be used. It is based on the Comba technique meaning that there are limits on 4105the size of the input. This algorithm is discussed in sub-section 6.3.3. 4106 4107Step 5 is the main reduction loop of the algorithm. The value of $\mu$ is calculated once per iteration in the outer loop. The inner loop 4108calculates $x + \mu n \beta^{ix}$ by multiplying $\mu n$ and adding the result to $x$ shifted by $ix$ digits. Both the addition and 4109multiplication are performed in the same loop to save time and memory. Step 5.4 will handle any additional carries that escape the inner loop. 4110 4111Using a quick inspection this algorithm requires $n$ single precision multiplications for the outer loop and $n^2$ single precision multiplications 4112in the inner loop. In total $n^2 + n$ single precision multiplications which compares favourably to Barrett at $n^2 + 2n - 1$ single precision 4113multiplications. 4114 4115\vspace{+3mm}\begin{small} 4116\hspace{-5.1mm}{\bf File}: bn\_mp\_montgomery\_reduce.c 4117\vspace{-3mm} 4118\begin{alltt} 4119\end{alltt} 4120\end{small} 4121 4122This is the baseline implementation of the Montgomery reduction algorithm. Lines 31 to 36 determine if the Comba based 4123routine can be used instead. Line 47 computes the value of $\mu$ for that particular iteration of the outer loop. 4124 4125The multiplication $\mu n \beta^{ix}$ is performed in one step in the inner loop. The alias $tmpx$ refers to the $ix$'th digit of $x$ and 4126the alias $tmpn$ refers to the modulus $n$. 4127 4128\subsection{Faster ``Comba'' Montgomery Reduction} 4129 4130The Montgomery reduction requires fewer single precision multiplications than a Barrett reduction, however it is much slower due to the serial 4131nature of the inner loop. The Barrett reduction algorithm requires two slightly modified multipliers which can be implemented with the Comba 4132technique. The Montgomery reduction algorithm cannot directly use the Comba technique to any significant advantage since the inner loop calculates 4133a $k \times 1$ product $k$ times. 4134 4135The biggest obstacle is that at the $ix$'th iteration of the outer loop the value of $x_{ix}$ is required to calculate $\mu$. This means the 4136carries from $0$ to $ix - 1$ must have been propagated upwards to form a valid $ix$'th digit. The solution as it turns out is very simple. 4137Perform a Comba like multiplier and inside the outer loop just after the inner loop fix up the $ix + 1$'th digit by forwarding the carry. 4138 4139With this change in place the Montgomery reduction algorithm can be performed with a Comba style multiplication loop which substantially increases 4140the speed of the algorithm. 4141 4142\newpage\begin{figure}[!here] 4143\begin{small} 4144\begin{center} 4145\begin{tabular}{l} 4146\hline Algorithm \textbf{fast\_mp\_montgomery\_reduce}. \\ 4147\textbf{Input}. mp\_int $x$, mp\_int $n$ and a digit $\rho \equiv -1/n_0 \mbox{ (mod }n\mbox{)}$. \\ 4148\hspace{11.5mm}($0 \le x < n^2, n > 1, (n, \beta) = 1, \beta^k > n$) \\ 4149\textbf{Output}. $\beta^{-k}x \mbox{ (mod }n\mbox{)}$ \\ 4150\hline \\ 4151Place an array of \textbf{MP\_WARRAY} mp\_word variables called $\hat W$ on the stack. \\ 41521. if $x.alloc < n.used + 1$ then grow $x$ to $n.used + 1$ digits. \\ 4153Copy the digits of $x$ into the array $\hat W$ \\ 41542. For $ix$ from $0$ to $x.used - 1$ do \\ 4155\hspace{3mm}2.1 $\hat W_{ix} \leftarrow x_{ix}$ \\ 41563. For $ix$ from $x.used$ to $2n.used - 1$ do \\ 4157\hspace{3mm}3.1 $\hat W_{ix} \leftarrow 0$ \\ 4158Elimiate the lower $k$ digits. \\ 41594. for $ix$ from $0$ to $n.used - 1$ do \\ 4160\hspace{3mm}4.1 $\mu \leftarrow \hat W_{ix} \cdot \rho \mbox{ (mod }\beta\mbox{)}$ \\ 4161\hspace{3mm}4.2 For $iy$ from $0$ to $n.used - 1$ do \\ 4162\hspace{6mm}4.2.1 $\hat W_{iy + ix} \leftarrow \hat W_{iy + ix} + \mu \cdot n_{iy}$ \\ 4163\hspace{3mm}4.3 $\hat W_{ix + 1} \leftarrow \hat W_{ix + 1} + \lfloor \hat W_{ix} / \beta \rfloor$ \\ 4164Propagate carries upwards. \\ 41655. for $ix$ from $n.used$ to $2n.used + 1$ do \\ 4166\hspace{3mm}5.1 $\hat W_{ix + 1} \leftarrow \hat W_{ix + 1} + \lfloor \hat W_{ix} / \beta \rfloor$ \\ 4167Shift right and reduce modulo $\beta$ simultaneously. \\ 41686. for $ix$ from $0$ to $n.used + 1$ do \\ 4169\hspace{3mm}6.1 $x_{ix} \leftarrow \hat W_{ix + n.used} \mbox{ (mod }\beta\mbox{)}$ \\ 4170Zero excess digits and fixup $x$. \\ 41717. if $x.used > n.used + 1$ then do \\ 4172\hspace{3mm}7.1 for $ix$ from $n.used + 1$ to $x.used - 1$ do \\ 4173\hspace{6mm}7.1.1 $x_{ix} \leftarrow 0$ \\ 41748. $x.used \leftarrow n.used + 1$ \\ 41759. Clamp excessive digits of $x$. \\ 417610. If $x \ge n$ then \\ 4177\hspace{3mm}10.1 $x \leftarrow x - n$ \\ 417811. Return(\textit{MP\_OKAY}). \\ 4179\hline 4180\end{tabular} 4181\end{center} 4182\end{small} 4183\caption{Algorithm fast\_mp\_montgomery\_reduce} 4184\end{figure} 4185 4186\textbf{Algorithm fast\_mp\_montgomery\_reduce.} 4187This algorithm will compute the Montgomery reduction of $x$ modulo $n$ using the Comba technique. It is on most computer platforms significantly 4188faster than algorithm mp\_montgomery\_reduce and algorithm mp\_reduce (\textit{Barrett reduction}). The algorithm has the same restrictions 4189on the input as the baseline reduction algorithm. An additional two restrictions are imposed on this algorithm. The number of digits $k$ in the 4190the modulus $n$ must not violate $MP\_WARRAY > 2k +1$ and $n < \delta$. When $\beta = 2^{28}$ this algorithm can be used to reduce modulo 4191a modulus of at most $3,556$ bits in length. 4192 4193As in the other Comba reduction algorithms there is a $\hat W$ array which stores the columns of the product. It is initially filled with the 4194contents of $x$ with the excess digits zeroed. The reduction loop is very similar the to the baseline loop at heart. The multiplication on step 41954.1 can be single precision only since $ab \mbox{ (mod }\beta\mbox{)} \equiv (a \mbox{ mod }\beta)(b \mbox{ mod }\beta)$. Some multipliers such 4196as those on the ARM processors take a variable length time to complete depending on the number of bytes of result it must produce. By performing 4197a single precision multiplication instead half the amount of time is spent. 4198 4199Also note that digit $\hat W_{ix}$ must have the carry from the $ix - 1$'th digit propagated upwards in order for this to work. That is what step 42004.3 will do. In effect over the $n.used$ iterations of the outer loop the $n.used$'th lower columns all have the their carries propagated forwards. Note 4201how the upper bits of those same words are not reduced modulo $\beta$. This is because those values will be discarded shortly and there is no 4202point. 4203 4204Step 5 will propagate the remainder of the carries upwards. On step 6 the columns are reduced modulo $\beta$ and shifted simultaneously as they are 4205stored in the destination $x$. 4206 4207\vspace{+3mm}\begin{small} 4208\hspace{-5.1mm}{\bf File}: bn\_fast\_mp\_montgomery\_reduce.c 4209\vspace{-3mm} 4210\begin{alltt} 4211\end{alltt} 4212\end{small} 4213 4214The $\hat W$ array is first filled with digits of $x$ on line 48 then the rest of the digits are zeroed on line 55. Both loops share 4215the same alias variables to make the code easier to read. 4216 4217The value of $\mu$ is calculated in an interesting fashion. First the value $\hat W_{ix}$ is reduced modulo $\beta$ and cast to a mp\_digit. This 4218forces the compiler to use a single precision multiplication and prevents any concerns about loss of precision. Line 110 fixes the carry 4219for the next iteration of the loop by propagating the carry from $\hat W_{ix}$ to $\hat W_{ix+1}$. 4220 4221The for loop on line 109 propagates the rest of the carries upwards through the columns. The for loop on line 126 reduces the columns 4222modulo $\beta$ and shifts them $k$ places at the same time. The alias $\_ \hat W$ actually refers to the array $\hat W$ starting at the $n.used$'th 4223digit, that is $\_ \hat W_{t} = \hat W_{n.used + t}$. 4224 4225\subsection{Montgomery Setup} 4226To calculate the variable $\rho$ a relatively simple algorithm will be required. 4227 4228\begin{figure}[!here] 4229\begin{small} 4230\begin{center} 4231\begin{tabular}{l} 4232\hline Algorithm \textbf{mp\_montgomery\_setup}. \\ 4233\textbf{Input}. mp\_int $n$ ($n > 1$ and $(n, 2) = 1$) \\ 4234\textbf{Output}. $\rho \equiv -1/n_0 \mbox{ (mod }\beta\mbox{)}$ \\ 4235\hline \\ 42361. $b \leftarrow n_0$ \\ 42372. If $b$ is even return(\textit{MP\_VAL}) \\ 42383. $x \leftarrow (((b + 2) \mbox{ AND } 4) << 1) + b$ \\ 42394. for $k$ from 0 to $\lceil lg(lg(\beta)) \rceil - 2$ do \\ 4240\hspace{3mm}4.1 $x \leftarrow x \cdot (2 - bx)$ \\ 42415. $\rho \leftarrow \beta - x \mbox{ (mod }\beta\mbox{)}$ \\ 42426. Return(\textit{MP\_OKAY}). \\ 4243\hline 4244\end{tabular} 4245\end{center} 4246\end{small} 4247\caption{Algorithm mp\_montgomery\_setup} 4248\end{figure} 4249 4250\textbf{Algorithm mp\_montgomery\_setup.} 4251This algorithm will calculate the value of $\rho$ required within the Montgomery reduction algorithms. It uses a very interesting trick 4252to calculate $1/n_0$ when $\beta$ is a power of two. 4253 4254\vspace{+3mm}\begin{small} 4255\hspace{-5.1mm}{\bf File}: bn\_mp\_montgomery\_setup.c 4256\vspace{-3mm} 4257\begin{alltt} 4258\end{alltt} 4259\end{small} 4260 4261This source code computes the value of $\rho$ required to perform Montgomery reduction. It has been modified to avoid performing excess 4262multiplications when $\beta$ is not the default 28-bits. 4263 4264\section{The Diminished Radix Algorithm} 4265The Diminished Radix method of modular reduction \cite{DRMET} is a fairly clever technique which can be more efficient than either the Barrett 4266or Montgomery methods for certain forms of moduli. The technique is based on the following simple congruence. 4267 4268\begin{equation} 4269(x \mbox{ mod } n) + k \lfloor x / n \rfloor \equiv x \mbox{ (mod }(n - k)\mbox{)} 4270\end{equation} 4271 4272This observation was used in the MMB \cite{MMB} block cipher to create a diffusion primitive. It used the fact that if $n = 2^{31}$ and $k=1$ that 4273then a x86 multiplier could produce the 62-bit product and use the ``shrd'' instruction to perform a double-precision right shift. The proof 4274of the above equation is very simple. First write $x$ in the product form. 4275 4276\begin{equation} 4277x = qn + r 4278\end{equation} 4279 4280Now reduce both sides modulo $(n - k)$. 4281 4282\begin{equation} 4283x \equiv qk + r \mbox{ (mod }(n-k)\mbox{)} 4284\end{equation} 4285 4286The variable $n$ reduces modulo $n - k$ to $k$. By putting $q = \lfloor x/n \rfloor$ and $r = x \mbox{ mod } n$ 4287into the equation the original congruence is reproduced, thus concluding the proof. The following algorithm is based on this observation. 4288 4289\begin{figure}[!here] 4290\begin{small} 4291\begin{center} 4292\begin{tabular}{l} 4293\hline Algorithm \textbf{Diminished Radix Reduction}. \\ 4294\textbf{Input}. Integer $x$, $n$, $k$ \\ 4295\textbf{Output}. $x \mbox{ mod } (n - k)$ \\ 4296\hline \\ 42971. $q \leftarrow \lfloor x / n \rfloor$ \\ 42982. $q \leftarrow k \cdot q$ \\ 42993. $x \leftarrow x \mbox{ (mod }n\mbox{)}$ \\ 43004. $x \leftarrow x + q$ \\ 43015. If $x \ge (n - k)$ then \\ 4302\hspace{3mm}5.1 $x \leftarrow x - (n - k)$ \\ 4303\hspace{3mm}5.2 Goto step 1. \\ 43046. Return $x$ \\ 4305\hline 4306\end{tabular} 4307\end{center} 4308\end{small} 4309\caption{Algorithm Diminished Radix Reduction} 4310\label{fig:DR} 4311\end{figure} 4312 4313This algorithm will reduce $x$ modulo $n - k$ and return the residue. If $0 \le x < (n - k)^2$ then the algorithm will loop almost always 4314once or twice and occasionally three times. For simplicity sake the value of $x$ is bounded by the following simple polynomial. 4315 4316\begin{equation} 43170 \le x < n^2 + k^2 - 2nk 4318\end{equation} 4319 4320The true bound is $0 \le x < (n - k - 1)^2$ but this has quite a few more terms. The value of $q$ after step 1 is bounded by the following. 4321 4322\begin{equation} 4323q < n - 2k - k^2/n 4324\end{equation} 4325 4326Since $k^2$ is going to be considerably smaller than $n$ that term will always be zero. The value of $x$ after step 3 is bounded trivially as 4327$0 \le x < n$. By step four the sum $x + q$ is bounded by 4328 4329\begin{equation} 43300 \le q + x < (k + 1)n - 2k^2 - 1 4331\end{equation} 4332 4333With a second pass $q$ will be loosely bounded by $0 \le q < k^2$ after step 2 while $x$ will still be loosely bounded by $0 \le x < n$ after step 3. After the second pass it is highly unlike that the 4334sum in step 4 will exceed $n - k$. In practice fewer than three passes of the algorithm are required to reduce virtually every input in the 4335range $0 \le x < (n - k - 1)^2$. 4336 4337\begin{figure} 4338\begin{small} 4339\begin{center} 4340\begin{tabular}{|l|} 4341\hline 4342$x = 123456789, n = 256, k = 3$ \\ 4343\hline $q \leftarrow \lfloor x/n \rfloor = 482253$ \\ 4344$q \leftarrow q*k = 1446759$ \\ 4345$x \leftarrow x \mbox{ mod } n = 21$ \\ 4346$x \leftarrow x + q = 1446780$ \\ 4347$x \leftarrow x - (n - k) = 1446527$ \\ 4348\hline 4349$q \leftarrow \lfloor x/n \rfloor = 5650$ \\ 4350$q \leftarrow q*k = 16950$ \\ 4351$x \leftarrow x \mbox{ mod } n = 127$ \\ 4352$x \leftarrow x + q = 17077$ \\ 4353$x \leftarrow x - (n - k) = 16824$ \\ 4354\hline 4355$q \leftarrow \lfloor x/n \rfloor = 65$ \\ 4356$q \leftarrow q*k = 195$ \\ 4357$x \leftarrow x \mbox{ mod } n = 184$ \\ 4358$x \leftarrow x + q = 379$ \\ 4359$x \leftarrow x - (n - k) = 126$ \\ 4360\hline 4361\end{tabular} 4362\end{center} 4363\end{small} 4364\caption{Example Diminished Radix Reduction} 4365\label{fig:EXDR} 4366\end{figure} 4367 4368Figure~\ref{fig:EXDR} demonstrates the reduction of $x = 123456789$ modulo $n - k = 253$ when $n = 256$ and $k = 3$. Note that even while $x$ 4369is considerably larger than $(n - k - 1)^2 = 63504$ the algorithm still converges on the modular residue exceedingly fast. In this case only 4370three passes were required to find the residue $x \equiv 126$. 4371 4372 4373\subsection{Choice of Moduli} 4374On the surface this algorithm looks like a very expensive algorithm. It requires a couple of subtractions followed by multiplication and other 4375modular reductions. The usefulness of this algorithm becomes exceedingly clear when an appropriate modulus is chosen. 4376 4377Division in general is a very expensive operation to perform. The one exception is when the division is by a power of the radix of representation used. 4378Division by ten for example is simple for pencil and paper mathematics since it amounts to shifting the decimal place to the right. Similarly division 4379by two (\textit{or powers of two}) is very simple for binary computers to perform. It would therefore seem logical to choose $n$ of the form $2^p$ 4380which would imply that $\lfloor x / n \rfloor$ is a simple shift of $x$ right $p$ bits. 4381 4382However, there is one operation related to division of power of twos that is even faster than this. If $n = \beta^p$ then the division may be 4383performed by moving whole digits to the right $p$ places. In practice division by $\beta^p$ is much faster than division by $2^p$ for any $p$. 4384Also with the choice of $n = \beta^p$ reducing $x$ modulo $n$ merely requires zeroing the digits above the $p-1$'th digit of $x$. 4385 4386Throughout the next section the term ``restricted modulus'' will refer to a modulus of the form $\beta^p - k$ whereas the term ``unrestricted 4387modulus'' will refer to a modulus of the form $2^p - k$. The word ``restricted'' in this case refers to the fact that it is based on the 4388$2^p$ logic except $p$ must be a multiple of $lg(\beta)$. 4389 4390\subsection{Choice of $k$} 4391Now that division and reduction (\textit{step 1 and 3 of figure~\ref{fig:DR}}) have been optimized to simple digit operations the multiplication by $k$ 4392in step 2 is the most expensive operation. Fortunately the choice of $k$ is not terribly limited. For all intents and purposes it might 4393as well be a single digit. The smaller the value of $k$ is the faster the algorithm will be. 4394 4395\subsection{Restricted Diminished Radix Reduction} 4396The restricted Diminished Radix algorithm can quickly reduce an input modulo a modulus of the form $n = \beta^p - k$. This algorithm can reduce 4397an input $x$ within the range $0 \le x < n^2$ using only a couple passes of the algorithm demonstrated in figure~\ref{fig:DR}. The implementation 4398of this algorithm has been optimized to avoid additional overhead associated with a division by $\beta^p$, the multiplication by $k$ or the addition 4399of $x$ and $q$. The resulting algorithm is very efficient and can lead to substantial improvements over Barrett and Montgomery reduction when modular 4400exponentiations are performed. 4401 4402\newpage\begin{figure}[!here] 4403\begin{small} 4404\begin{center} 4405\begin{tabular}{l} 4406\hline Algorithm \textbf{mp\_dr\_reduce}. \\ 4407\textbf{Input}. mp\_int $x$, $n$ and a mp\_digit $k = \beta - n_0$ \\ 4408\hspace{11.5mm}($0 \le x < n^2$, $n > 1$, $0 < k < \beta$) \\ 4409\textbf{Output}. $x \mbox{ mod } n$ \\ 4410\hline \\ 44111. $m \leftarrow n.used$ \\ 44122. If $x.alloc < 2m$ then grow $x$ to $2m$ digits. \\ 44133. $\mu \leftarrow 0$ \\ 44144. for $i$ from $0$ to $m - 1$ do \\ 4415\hspace{3mm}4.1 $\hat r \leftarrow k \cdot x_{m+i} + x_{i} + \mu$ \\ 4416\hspace{3mm}4.2 $x_{i} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\ 4417\hspace{3mm}4.3 $\mu \leftarrow \lfloor \hat r / \beta \rfloor$ \\ 44185. $x_{m} \leftarrow \mu$ \\ 44196. for $i$ from $m + 1$ to $x.used - 1$ do \\ 4420\hspace{3mm}6.1 $x_{i} \leftarrow 0$ \\ 44217. Clamp excess digits of $x$. \\ 44228. If $x \ge n$ then \\ 4423\hspace{3mm}8.1 $x \leftarrow x - n$ \\ 4424\hspace{3mm}8.2 Goto step 3. \\ 44259. Return(\textit{MP\_OKAY}). \\ 4426\hline 4427\end{tabular} 4428\end{center} 4429\end{small} 4430\caption{Algorithm mp\_dr\_reduce} 4431\end{figure} 4432 4433\textbf{Algorithm mp\_dr\_reduce.} 4434This algorithm will perform the Dimished Radix reduction of $x$ modulo $n$. It has similar restrictions to that of the Barrett reduction 4435with the addition that $n$ must be of the form $n = \beta^m - k$ where $0 < k <\beta$. 4436 4437This algorithm essentially implements the pseudo-code in figure~\ref{fig:DR} except with a slight optimization. The division by $\beta^m$, multiplication by $k$ 4438and addition of $x \mbox{ mod }\beta^m$ are all performed simultaneously inside the loop on step 4. The division by $\beta^m$ is emulated by accessing 4439the term at the $m+i$'th position which is subsequently multiplied by $k$ and added to the term at the $i$'th position. After the loop the $m$'th 4440digit is set to the carry and the upper digits are zeroed. Steps 5 and 6 emulate the reduction modulo $\beta^m$ that should have happend to 4441$x$ before the addition of the multiple of the upper half. 4442 4443At step 8 if $x$ is still larger than $n$ another pass of the algorithm is required. First $n$ is subtracted from $x$ and then the algorithm resumes 4444at step 3. 4445 4446\vspace{+3mm}\begin{small} 4447\hspace{-5.1mm}{\bf File}: bn\_mp\_dr\_reduce.c 4448\vspace{-3mm} 4449\begin{alltt} 4450\end{alltt} 4451\end{small} 4452 4453The first step is to grow $x$ as required to $2m$ digits since the reduction is performed in place on $x$. The label on line 52 is where 4454the algorithm will resume if further reduction passes are required. In theory it could be placed at the top of the function however, the size of 4455the modulus and question of whether $x$ is large enough are invariant after the first pass meaning that it would be a waste of time. 4456 4457The aliases $tmpx1$ and $tmpx2$ refer to the digits of $x$ where the latter is offset by $m$ digits. By reading digits from $x$ offset by $m$ digits 4458a division by $\beta^m$ can be simulated virtually for free. The loop on line 64 performs the bulk of the work (\textit{corresponds to step 4 of algorithm 7.11}) 4459in this algorithm. 4460 4461By line 67 the pointer $tmpx1$ points to the $m$'th digit of $x$ which is where the final carry will be placed. Similarly by line 74 the 4462same pointer will point to the $m+1$'th digit where the zeroes will be placed. 4463 4464Since the algorithm is only valid if both $x$ and $n$ are greater than zero an unsigned comparison suffices to determine if another pass is required. 4465With the same logic at line 81 the value of $x$ is known to be greater than or equal to $n$ meaning that an unsigned subtraction can be used 4466as well. Since the destination of the subtraction is the larger of the inputs the call to algorithm s\_mp\_sub cannot fail and the return code 4467does not need to be checked. 4468 4469\subsubsection{Setup} 4470To setup the restricted Diminished Radix algorithm the value $k = \beta - n_0$ is required. This algorithm is not really complicated but provided for 4471completeness. 4472 4473\begin{figure}[!here] 4474\begin{small} 4475\begin{center} 4476\begin{tabular}{l} 4477\hline Algorithm \textbf{mp\_dr\_setup}. \\ 4478\textbf{Input}. mp\_int $n$ \\ 4479\textbf{Output}. $k = \beta - n_0$ \\ 4480\hline \\ 44811. $k \leftarrow \beta - n_0$ \\ 4482\hline 4483\end{tabular} 4484\end{center} 4485\end{small} 4486\caption{Algorithm mp\_dr\_setup} 4487\end{figure} 4488 4489\vspace{+3mm}\begin{small} 4490\hspace{-5.1mm}{\bf File}: bn\_mp\_dr\_setup.c 4491\vspace{-3mm} 4492\begin{alltt} 4493\end{alltt} 4494\end{small} 4495 4496\subsubsection{Modulus Detection} 4497Another algorithm which will be useful is the ability to detect a restricted Diminished Radix modulus. An integer is said to be 4498of restricted Diminished Radix form if all of the digits are equal to $\beta - 1$ except the trailing digit which may be any value. 4499 4500\begin{figure}[!here] 4501\begin{small} 4502\begin{center} 4503\begin{tabular}{l} 4504\hline Algorithm \textbf{mp\_dr\_is\_modulus}. \\ 4505\textbf{Input}. mp\_int $n$ \\ 4506\textbf{Output}. $1$ if $n$ is in D.R form, $0$ otherwise \\ 4507\hline 45081. If $n.used < 2$ then return($0$). \\ 45092. for $ix$ from $1$ to $n.used - 1$ do \\ 4510\hspace{3mm}2.1 If $n_{ix} \ne \beta - 1$ return($0$). \\ 45113. Return($1$). \\ 4512\hline 4513\end{tabular} 4514\end{center} 4515\end{small} 4516\caption{Algorithm mp\_dr\_is\_modulus} 4517\end{figure} 4518 4519\textbf{Algorithm mp\_dr\_is\_modulus.} 4520This algorithm determines if a value is in Diminished Radix form. Step 1 rejects obvious cases where fewer than two digits are 4521in the mp\_int. Step 2 tests all but the first digit to see if they are equal to $\beta - 1$. If the algorithm manages to get to 4522step 3 then $n$ must be of Diminished Radix form. 4523 4524\vspace{+3mm}\begin{small} 4525\hspace{-5.1mm}{\bf File}: bn\_mp\_dr\_is\_modulus.c 4526\vspace{-3mm} 4527\begin{alltt} 4528\end{alltt} 4529\end{small} 4530 4531\subsection{Unrestricted Diminished Radix Reduction} 4532The unrestricted Diminished Radix algorithm allows modular reductions to be performed when the modulus is of the form $2^p - k$. This algorithm 4533is a straightforward adaptation of algorithm~\ref{fig:DR}. 4534 4535In general the restricted Diminished Radix reduction algorithm is much faster since it has considerably lower overhead. However, this new 4536algorithm is much faster than either Montgomery or Barrett reduction when the moduli are of the appropriate form. 4537 4538\begin{figure}[!here] 4539\begin{small} 4540\begin{center} 4541\begin{tabular}{l} 4542\hline Algorithm \textbf{mp\_reduce\_2k}. \\ 4543\textbf{Input}. mp\_int $a$ and $n$. mp\_digit $k$ \\ 4544\hspace{11.5mm}($a \ge 0$, $n > 1$, $0 < k < \beta$, $n + k$ is a power of two) \\ 4545\textbf{Output}. $a \mbox{ (mod }n\mbox{)}$ \\ 4546\hline 45471. $p \leftarrow \lceil lg(n) \rceil$ (\textit{mp\_count\_bits}) \\ 45482. While $a \ge n$ do \\ 4549\hspace{3mm}2.1 $q \leftarrow \lfloor a / 2^p \rfloor$ (\textit{mp\_div\_2d}) \\ 4550\hspace{3mm}2.2 $a \leftarrow a \mbox{ (mod }2^p\mbox{)}$ (\textit{mp\_mod\_2d}) \\ 4551\hspace{3mm}2.3 $q \leftarrow q \cdot k$ (\textit{mp\_mul\_d}) \\ 4552\hspace{3mm}2.4 $a \leftarrow a - q$ (\textit{s\_mp\_sub}) \\ 4553\hspace{3mm}2.5 If $a \ge n$ then do \\ 4554\hspace{6mm}2.5.1 $a \leftarrow a - n$ \\ 45553. Return(\textit{MP\_OKAY}). \\ 4556\hline 4557\end{tabular} 4558\end{center} 4559\end{small} 4560\caption{Algorithm mp\_reduce\_2k} 4561\end{figure} 4562 4563\textbf{Algorithm mp\_reduce\_2k.} 4564This algorithm quickly reduces an input $a$ modulo an unrestricted Diminished Radix modulus $n$. Division by $2^p$ is emulated with a right 4565shift which makes the algorithm fairly inexpensive to use. 4566 4567\vspace{+3mm}\begin{small} 4568\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce\_2k.c 4569\vspace{-3mm} 4570\begin{alltt} 4571\end{alltt} 4572\end{small} 4573 4574The algorithm mp\_count\_bits calculates the number of bits in an mp\_int which is used to find the initial value of $p$. The call to mp\_div\_2d 4575on line 31 calculates both the quotient $q$ and the remainder $a$ required. By doing both in a single function call the code size 4576is kept fairly small. The multiplication by $k$ is only performed if $k > 1$. This allows reductions modulo $2^p - 1$ to be performed without 4577any multiplications. 4578 4579The unsigned s\_mp\_add, mp\_cmp\_mag and s\_mp\_sub are used in place of their full sign counterparts since the inputs are only valid if they are 4580positive. By using the unsigned versions the overhead is kept to a minimum. 4581 4582\subsubsection{Unrestricted Setup} 4583To setup this reduction algorithm the value of $k = 2^p - n$ is required. 4584 4585\begin{figure}[!here] 4586\begin{small} 4587\begin{center} 4588\begin{tabular}{l} 4589\hline Algorithm \textbf{mp\_reduce\_2k\_setup}. \\ 4590\textbf{Input}. mp\_int $n$ \\ 4591\textbf{Output}. $k = 2^p - n$ \\ 4592\hline 45931. $p \leftarrow \lceil lg(n) \rceil$ (\textit{mp\_count\_bits}) \\ 45942. $x \leftarrow 2^p$ (\textit{mp\_2expt}) \\ 45953. $x \leftarrow x - n$ (\textit{mp\_sub}) \\ 45964. $k \leftarrow x_0$ \\ 45975. Return(\textit{MP\_OKAY}). \\ 4598\hline 4599\end{tabular} 4600\end{center} 4601\end{small} 4602\caption{Algorithm mp\_reduce\_2k\_setup} 4603\end{figure} 4604 4605\textbf{Algorithm mp\_reduce\_2k\_setup.} 4606This algorithm computes the value of $k$ required for the algorithm mp\_reduce\_2k. By making a temporary variable $x$ equal to $2^p$ a subtraction 4607is sufficient to solve for $k$. Alternatively if $n$ has more than one digit the value of $k$ is simply $\beta - n_0$. 4608 4609\vspace{+3mm}\begin{small} 4610\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce\_2k\_setup.c 4611\vspace{-3mm} 4612\begin{alltt} 4613\end{alltt} 4614\end{small} 4615 4616\subsubsection{Unrestricted Detection} 4617An integer $n$ is a valid unrestricted Diminished Radix modulus if either of the following are true. 4618 4619\begin{enumerate} 4620\item The number has only one digit. 4621\item The number has more than one digit and every bit from the $\beta$'th to the most significant is one. 4622\end{enumerate} 4623 4624If either condition is true than there is a power of two $2^p$ such that $0 < 2^p - n < \beta$. If the input is only 4625one digit than it will always be of the correct form. Otherwise all of the bits above the first digit must be one. This arises from the fact 4626that there will be value of $k$ that when added to the modulus causes a carry in the first digit which propagates all the way to the most 4627significant bit. The resulting sum will be a power of two. 4628 4629\begin{figure}[!here] 4630\begin{small} 4631\begin{center} 4632\begin{tabular}{l} 4633\hline Algorithm \textbf{mp\_reduce\_is\_2k}. \\ 4634\textbf{Input}. mp\_int $n$ \\ 4635\textbf{Output}. $1$ if of proper form, $0$ otherwise \\ 4636\hline 46371. If $n.used = 0$ then return($0$). \\ 46382. If $n.used = 1$ then return($1$). \\ 46393. $p \leftarrow \lceil lg(n) \rceil$ (\textit{mp\_count\_bits}) \\ 46404. for $x$ from $lg(\beta)$ to $p$ do \\ 4641\hspace{3mm}4.1 If the ($x \mbox{ mod }lg(\beta)$)'th bit of the $\lfloor x / lg(\beta) \rfloor$ of $n$ is zero then return($0$). \\ 46425. Return($1$). \\ 4643\hline 4644\end{tabular} 4645\end{center} 4646\end{small} 4647\caption{Algorithm mp\_reduce\_is\_2k} 4648\end{figure} 4649 4650\textbf{Algorithm mp\_reduce\_is\_2k.} 4651This algorithm quickly determines if a modulus is of the form required for algorithm mp\_reduce\_2k to function properly. 4652 4653\vspace{+3mm}\begin{small} 4654\hspace{-5.1mm}{\bf File}: bn\_mp\_reduce\_is\_2k.c 4655\vspace{-3mm} 4656\begin{alltt} 4657\end{alltt} 4658\end{small} 4659 4660 4661 4662\section{Algorithm Comparison} 4663So far three very different algorithms for modular reduction have been discussed. Each of the algorithms have their own strengths and weaknesses 4664that makes having such a selection very useful. The following table sumarizes the three algorithms along with comparisons of work factors. Since 4665all three algorithms have the restriction that $0 \le x < n^2$ and $n > 1$ those limitations are not included in the table. 4666 4667\begin{center} 4668\begin{small} 4669\begin{tabular}{|c|c|c|c|c|c|} 4670\hline \textbf{Method} & \textbf{Work Required} & \textbf{Limitations} & \textbf{$m = 8$} & \textbf{$m = 32$} & \textbf{$m = 64$} \\ 4671\hline Barrett & $m^2 + 2m - 1$ & None & $79$ & $1087$ & $4223$ \\ 4672\hline Montgomery & $m^2 + m$ & $n$ must be odd & $72$ & $1056$ & $4160$ \\ 4673\hline D.R. & $2m$ & $n = \beta^m - k$ & $16$ & $64$ & $128$ \\ 4674\hline 4675\end{tabular} 4676\end{small} 4677\end{center} 4678 4679In theory Montgomery and Barrett reductions would require roughly the same amount of time to complete. However, in practice since Montgomery 4680reduction can be written as a single function with the Comba technique it is much faster. Barrett reduction suffers from the overhead of 4681calling the half precision multipliers, addition and division by $\beta$ algorithms. 4682 4683For almost every cryptographic algorithm Montgomery reduction is the algorithm of choice. The one set of algorithms where Diminished Radix reduction truly 4684shines are based on the discrete logarithm problem such as Diffie-Hellman \cite{DH} and ElGamal \cite{ELGAMAL}. In these algorithms 4685primes of the form $\beta^m - k$ can be found and shared amongst users. These primes will allow the Diminished Radix algorithm to be used in 4686modular exponentiation to greatly speed up the operation. 4687 4688 4689 4690\section*{Exercises} 4691\begin{tabular}{cl} 4692$\left [ 3 \right ]$ & Prove that the ``trick'' in algorithm mp\_montgomery\_setup actually \\ 4693 & calculates the correct value of $\rho$. \\ 4694 & \\ 4695$\left [ 2 \right ]$ & Devise an algorithm to reduce modulo $n + k$ for small $k$ quickly. \\ 4696 & \\ 4697$\left [ 4 \right ]$ & Prove that the pseudo-code algorithm ``Diminished Radix Reduction'' \\ 4698 & (\textit{figure~\ref{fig:DR}}) terminates. Also prove the probability that it will \\ 4699 & terminate within $1 \le k \le 10$ iterations. \\ 4700 & \\ 4701\end{tabular} 4702 4703 4704\chapter{Exponentiation} 4705Exponentiation is the operation of raising one variable to the power of another, for example, $a^b$. A variant of exponentiation, computed 4706in a finite field or ring, is called modular exponentiation. This latter style of operation is typically used in public key 4707cryptosystems such as RSA and Diffie-Hellman. The ability to quickly compute modular exponentiations is of great benefit to any 4708such cryptosystem and many methods have been sought to speed it up. 4709 4710\section{Exponentiation Basics} 4711A trivial algorithm would simply multiply $a$ against itself $b - 1$ times to compute the exponentiation desired. However, as $b$ grows in size 4712the number of multiplications becomes prohibitive. Imagine what would happen if $b$ $\approx$ $2^{1024}$ as is the case when computing an RSA signature 4713with a $1024$-bit key. Such a calculation could never be completed as it would take simply far too long. 4714 4715Fortunately there is a very simple algorithm based on the laws of exponents. Recall that $lg_a(a^b) = b$ and that $lg_a(a^ba^c) = b + c$ which 4716are two trivial relationships between the base and the exponent. Let $b_i$ represent the $i$'th bit of $b$ starting from the least 4717significant bit. If $b$ is a $k$-bit integer than the following equation is true. 4718 4719\begin{equation} 4720a^b = \prod_{i=0}^{k-1} a^{2^i \cdot b_i} 4721\end{equation} 4722 4723By taking the base $a$ logarithm of both sides of the equation the following equation is the result. 4724 4725\begin{equation} 4726b = \sum_{i=0}^{k-1}2^i \cdot b_i 4727\end{equation} 4728 4729The term $a^{2^i}$ can be found from the $i - 1$'th term by squaring the term since $\left ( a^{2^i} \right )^2$ is equal to 4730$a^{2^{i+1}}$. This observation forms the basis of essentially all fast exponentiation algorithms. It requires $k$ squarings and on average 4731$k \over 2$ multiplications to compute the result. This is indeed quite an improvement over simply multiplying by $a$ a total of $b-1$ times. 4732 4733While this current method is a considerable speed up there are further improvements to be made. For example, the $a^{2^i}$ term does not need to 4734be computed in an auxilary variable. Consider the following equivalent algorithm. 4735 4736\begin{figure}[!here] 4737\begin{small} 4738\begin{center} 4739\begin{tabular}{l} 4740\hline Algorithm \textbf{Left to Right Exponentiation}. \\ 4741\textbf{Input}. Integer $a$, $b$ and $k$ \\ 4742\textbf{Output}. $c = a^b$ \\ 4743\hline \\ 47441. $c \leftarrow 1$ \\ 47452. for $i$ from $k - 1$ to $0$ do \\ 4746\hspace{3mm}2.1 $c \leftarrow c^2$ \\ 4747\hspace{3mm}2.2 $c \leftarrow c \cdot a^{b_i}$ \\ 47483. Return $c$. \\ 4749\hline 4750\end{tabular} 4751\end{center} 4752\end{small} 4753\caption{Left to Right Exponentiation} 4754\label{fig:LTOR} 4755\end{figure} 4756 4757This algorithm starts from the most significant bit and works towards the least significant bit. When the $i$'th bit of $b$ is set $a$ is 4758multiplied against the current product. In each iteration the product is squared which doubles the exponent of the individual terms of the 4759product. 4760 4761For example, let $b = 101100_2 \equiv 44_{10}$. The following chart demonstrates the actions of the algorithm. 4762 4763\newpage\begin{figure} 4764\begin{center} 4765\begin{tabular}{|c|c|} 4766\hline \textbf{Value of $i$} & \textbf{Value of $c$} \\ 4767\hline - & $1$ \\ 4768\hline $5$ & $a$ \\ 4769\hline $4$ & $a^2$ \\ 4770\hline $3$ & $a^4 \cdot a$ \\ 4771\hline $2$ & $a^8 \cdot a^2 \cdot a$ \\ 4772\hline $1$ & $a^{16} \cdot a^4 \cdot a^2$ \\ 4773\hline $0$ & $a^{32} \cdot a^8 \cdot a^4$ \\ 4774\hline 4775\end{tabular} 4776\end{center} 4777\caption{Example of Left to Right Exponentiation} 4778\end{figure} 4779 4780When the product $a^{32} \cdot a^8 \cdot a^4$ is simplified it is equal $a^{44}$ which is the desired exponentiation. This particular algorithm is 4781called ``Left to Right'' because it reads the exponent in that order. All of the exponentiation algorithms that will be presented are of this nature. 4782 4783\subsection{Single Digit Exponentiation} 4784The first algorithm in the series of exponentiation algorithms will be an unbounded algorithm where the exponent is a single digit. It is intended 4785to be used when a small power of an input is required (\textit{e.g. $a^5$}). It is faster than simply multiplying $b - 1$ times for all values of 4786$b$ that are greater than three. 4787 4788\newpage\begin{figure}[!here] 4789\begin{small} 4790\begin{center} 4791\begin{tabular}{l} 4792\hline Algorithm \textbf{mp\_expt\_d}. \\ 4793\textbf{Input}. mp\_int $a$ and mp\_digit $b$ \\ 4794\textbf{Output}. $c = a^b$ \\ 4795\hline \\ 47961. $g \leftarrow a$ (\textit{mp\_init\_copy}) \\ 47972. $c \leftarrow 1$ (\textit{mp\_set}) \\ 47983. for $x$ from 1 to $lg(\beta)$ do \\ 4799\hspace{3mm}3.1 $c \leftarrow c^2$ (\textit{mp\_sqr}) \\ 4800\hspace{3mm}3.2 If $b$ AND $2^{lg(\beta) - 1} \ne 0$ then \\ 4801\hspace{6mm}3.2.1 $c \leftarrow c \cdot g$ (\textit{mp\_mul}) \\ 4802\hspace{3mm}3.3 $b \leftarrow b << 1$ \\ 48034. Clear $g$. \\ 48045. Return(\textit{MP\_OKAY}). \\ 4805\hline 4806\end{tabular} 4807\end{center} 4808\end{small} 4809\caption{Algorithm mp\_expt\_d} 4810\end{figure} 4811 4812\textbf{Algorithm mp\_expt\_d.} 4813This algorithm computes the value of $a$ raised to the power of a single digit $b$. It uses the left to right exponentiation algorithm to 4814quickly compute the exponentiation. It is loosely based on algorithm 14.79 of HAC \cite[pp. 615]{HAC} with the difference that the 4815exponent is a fixed width. 4816 4817A copy of $a$ is made first to allow destination variable $c$ be the same as the source variable $a$. The result is set to the initial value of 4818$1$ in the subsequent step. 4819 4820Inside the loop the exponent is read from the most significant bit first down to the least significant bit. First $c$ is invariably squared 4821on step 3.1. In the following step if the most significant bit of $b$ is one the copy of $a$ is multiplied against $c$. The value 4822of $b$ is shifted left one bit to make the next bit down from the most signficant bit the new most significant bit. In effect each 4823iteration of the loop moves the bits of the exponent $b$ upwards to the most significant location. 4824 4825\vspace{+3mm}\begin{small} 4826\hspace{-5.1mm}{\bf File}: bn\_mp\_expt\_d.c 4827\vspace{-3mm} 4828\begin{alltt} 4829\end{alltt} 4830\end{small} 4831 4832Line 29 sets the initial value of the result to $1$. Next the loop on line 31 steps through each bit of the exponent starting from 4833the most significant down towards the least significant. The invariant squaring operation placed on line 33 is performed first. After 4834the squaring the result $c$ is multiplied by the base $g$ if and only if the most significant bit of the exponent is set. The shift on line 483547 moves all of the bits of the exponent upwards towards the most significant location. 4836 4837\section{$k$-ary Exponentiation} 4838When calculating an exponentiation the most time consuming bottleneck is the multiplications which are in general a small factor 4839slower than squaring. Recall from the previous algorithm that $b_{i}$ refers to the $i$'th bit of the exponent $b$. Suppose instead it referred to 4840the $i$'th $k$-bit digit of the exponent of $b$. For $k = 1$ the definitions are synonymous and for $k > 1$ algorithm~\ref{fig:KARY} 4841computes the same exponentiation. A group of $k$ bits from the exponent is called a \textit{window}. That is it is a small window on only a 4842portion of the entire exponent. Consider the following modification to the basic left to right exponentiation algorithm. 4843 4844\begin{figure}[!here] 4845\begin{small} 4846\begin{center} 4847\begin{tabular}{l} 4848\hline Algorithm \textbf{$k$-ary Exponentiation}. \\ 4849\textbf{Input}. Integer $a$, $b$, $k$ and $t$ \\ 4850\textbf{Output}. $c = a^b$ \\ 4851\hline \\ 48521. $c \leftarrow 1$ \\ 48532. for $i$ from $t - 1$ to $0$ do \\ 4854\hspace{3mm}2.1 $c \leftarrow c^{2^k} $ \\ 4855\hspace{3mm}2.2 Extract the $i$'th $k$-bit word from $b$ and store it in $g$. \\ 4856\hspace{3mm}2.3 $c \leftarrow c \cdot a^g$ \\ 48573. Return $c$. \\ 4858\hline 4859\end{tabular} 4860\end{center} 4861\end{small} 4862\caption{$k$-ary Exponentiation} 4863\label{fig:KARY} 4864\end{figure} 4865 4866The squaring on step 2.1 can be calculated by squaring the value $c$ successively $k$ times. If the values of $a^g$ for $0 < g < 2^k$ have been 4867precomputed this algorithm requires only $t$ multiplications and $tk$ squarings. The table can be generated with $2^{k - 1} - 1$ squarings and 4868$2^{k - 1} + 1$ multiplications. This algorithm assumes that the number of bits in the exponent is evenly divisible by $k$. 4869However, when it is not the remaining $0 < x \le k - 1$ bits can be handled with algorithm~\ref{fig:LTOR}. 4870 4871Suppose $k = 4$ and $t = 100$. This modified algorithm will require $109$ multiplications and $408$ squarings to compute the exponentiation. The 4872original algorithm would on average have required $200$ multiplications and $400$ squrings to compute the same value. The total number of squarings 4873has increased slightly but the number of multiplications has nearly halved. 4874 4875\subsection{Optimal Values of $k$} 4876An optimal value of $k$ will minimize $2^{k} + \lceil n / k \rceil + n - 1$ for a fixed number of bits in the exponent $n$. The simplest 4877approach is to brute force search amongst the values $k = 2, 3, \ldots, 8$ for the lowest result. Table~\ref{fig:OPTK} lists optimal values of $k$ 4878for various exponent sizes and compares the number of multiplication and squarings required against algorithm~\ref{fig:LTOR}. 4879 4880\begin{figure}[here] 4881\begin{center} 4882\begin{small} 4883\begin{tabular}{|c|c|c|c|c|c|} 4884\hline \textbf{Exponent (bits)} & \textbf{Optimal $k$} & \textbf{Work at $k$} & \textbf{Work with ~\ref{fig:LTOR}} \\ 4885\hline $16$ & $2$ & $27$ & $24$ \\ 4886\hline $32$ & $3$ & $49$ & $48$ \\ 4887\hline $64$ & $3$ & $92$ & $96$ \\ 4888\hline $128$ & $4$ & $175$ & $192$ \\ 4889\hline $256$ & $4$ & $335$ & $384$ \\ 4890\hline $512$ & $5$ & $645$ & $768$ \\ 4891\hline $1024$ & $6$ & $1257$ & $1536$ \\ 4892\hline $2048$ & $6$ & $2452$ & $3072$ \\ 4893\hline $4096$ & $7$ & $4808$ & $6144$ \\ 4894\hline 4895\end{tabular} 4896\end{small} 4897\end{center} 4898\caption{Optimal Values of $k$ for $k$-ary Exponentiation} 4899\label{fig:OPTK} 4900\end{figure} 4901 4902\subsection{Sliding-Window Exponentiation} 4903A simple modification to the previous algorithm is only generate the upper half of the table in the range $2^{k-1} \le g < 2^k$. Essentially 4904this is a table for all values of $g$ where the most significant bit of $g$ is a one. However, in order for this to be allowed in the 4905algorithm values of $g$ in the range $0 \le g < 2^{k-1}$ must be avoided. 4906 4907Table~\ref{fig:OPTK2} lists optimal values of $k$ for various exponent sizes and compares the work required against algorithm~\ref{fig:KARY}. 4908 4909\begin{figure}[here] 4910\begin{center} 4911\begin{small} 4912\begin{tabular}{|c|c|c|c|c|c|} 4913\hline \textbf{Exponent (bits)} & \textbf{Optimal $k$} & \textbf{Work at $k$} & \textbf{Work with ~\ref{fig:KARY}} \\ 4914\hline $16$ & $3$ & $24$ & $27$ \\ 4915\hline $32$ & $3$ & $45$ & $49$ \\ 4916\hline $64$ & $4$ & $87$ & $92$ \\ 4917\hline $128$ & $4$ & $167$ & $175$ \\ 4918\hline $256$ & $5$ & $322$ & $335$ \\ 4919\hline $512$ & $6$ & $628$ & $645$ \\ 4920\hline $1024$ & $6$ & $1225$ & $1257$ \\ 4921\hline $2048$ & $7$ & $2403$ & $2452$ \\ 4922\hline $4096$ & $8$ & $4735$ & $4808$ \\ 4923\hline 4924\end{tabular} 4925\end{small} 4926\end{center} 4927\caption{Optimal Values of $k$ for Sliding Window Exponentiation} 4928\label{fig:OPTK2} 4929\end{figure} 4930 4931\newpage\begin{figure}[!here] 4932\begin{small} 4933\begin{center} 4934\begin{tabular}{l} 4935\hline Algorithm \textbf{Sliding Window $k$-ary Exponentiation}. \\ 4936\textbf{Input}. Integer $a$, $b$, $k$ and $t$ \\ 4937\textbf{Output}. $c = a^b$ \\ 4938\hline \\ 49391. $c \leftarrow 1$ \\ 49402. for $i$ from $t - 1$ to $0$ do \\ 4941\hspace{3mm}2.1 If the $i$'th bit of $b$ is a zero then \\ 4942\hspace{6mm}2.1.1 $c \leftarrow c^2$ \\ 4943\hspace{3mm}2.2 else do \\ 4944\hspace{6mm}2.2.1 $c \leftarrow c^{2^k}$ \\ 4945\hspace{6mm}2.2.2 Extract the $k$ bits from $(b_{i}b_{i-1}\ldots b_{i-(k-1)})$ and store it in $g$. \\ 4946\hspace{6mm}2.2.3 $c \leftarrow c \cdot a^g$ \\ 4947\hspace{6mm}2.2.4 $i \leftarrow i - k$ \\ 49483. Return $c$. \\ 4949\hline 4950\end{tabular} 4951\end{center} 4952\end{small} 4953\caption{Sliding Window $k$-ary Exponentiation} 4954\end{figure} 4955 4956Similar to the previous algorithm this algorithm must have a special handler when fewer than $k$ bits are left in the exponent. While this 4957algorithm requires the same number of squarings it can potentially have fewer multiplications. The pre-computed table $a^g$ is also half 4958the size as the previous table. 4959 4960Consider the exponent $b = 111101011001000_2 \equiv 31432_{10}$ with $k = 3$ using both algorithms. The first algorithm will divide the exponent up as 4961the following five $3$-bit words $b \equiv \left ( 111, 101, 011, 001, 000 \right )_{2}$. The second algorithm will break the 4962exponent as $b \equiv \left ( 111, 101, 0, 110, 0, 100, 0 \right )_{2}$. The single digit $0$ in the second representation are where 4963a single squaring took place instead of a squaring and multiplication. In total the first method requires $10$ multiplications and $18$ 4964squarings. The second method requires $8$ multiplications and $18$ squarings. 4965 4966In general the sliding window method is never slower than the generic $k$-ary method and often it is slightly faster. 4967 4968\section{Modular Exponentiation} 4969 4970Modular exponentiation is essentially computing the power of a base within a finite field or ring. For example, computing 4971$d \equiv a^b \mbox{ (mod }c\mbox{)}$ is a modular exponentiation. Instead of first computing $a^b$ and then reducing it 4972modulo $c$ the intermediate result is reduced modulo $c$ after every squaring or multiplication operation. 4973 4974This guarantees that any intermediate result is bounded by $0 \le d \le c^2 - 2c + 1$ and can be reduced modulo $c$ quickly using 4975one of the algorithms presented in chapter six. 4976 4977Before the actual modular exponentiation algorithm can be written a wrapper algorithm must be written first. This algorithm 4978will allow the exponent $b$ to be negative which is computed as $c \equiv \left (1 / a \right )^{\vert b \vert} \mbox{(mod }d\mbox{)}$. The 4979value of $(1/a) \mbox{ mod }c$ is computed using the modular inverse (\textit{see \ref{sec;modinv}}). If no inverse exists the algorithm 4980terminates with an error. 4981 4982\begin{figure}[!here] 4983\begin{small} 4984\begin{center} 4985\begin{tabular}{l} 4986\hline Algorithm \textbf{mp\_exptmod}. \\ 4987\textbf{Input}. mp\_int $a$, $b$ and $c$ \\ 4988\textbf{Output}. $y \equiv g^x \mbox{ (mod }p\mbox{)}$ \\ 4989\hline \\ 49901. If $c.sign = MP\_NEG$ return(\textit{MP\_VAL}). \\ 49912. If $b.sign = MP\_NEG$ then \\ 4992\hspace{3mm}2.1 $g' \leftarrow g^{-1} \mbox{ (mod }c\mbox{)}$ \\ 4993\hspace{3mm}2.2 $x' \leftarrow \vert x \vert$ \\ 4994\hspace{3mm}2.3 Compute $d \equiv g'^{x'} \mbox{ (mod }c\mbox{)}$ via recursion. \\ 49953. if $p$ is odd \textbf{OR} $p$ is a D.R. modulus then \\ 4996\hspace{3mm}3.1 Compute $y \equiv g^{x} \mbox{ (mod }p\mbox{)}$ via algorithm mp\_exptmod\_fast. \\ 49974. else \\ 4998\hspace{3mm}4.1 Compute $y \equiv g^{x} \mbox{ (mod }p\mbox{)}$ via algorithm s\_mp\_exptmod. \\ 4999\hline 5000\end{tabular} 5001\end{center} 5002\end{small} 5003\caption{Algorithm mp\_exptmod} 5004\end{figure} 5005 5006\textbf{Algorithm mp\_exptmod.} 5007The first algorithm which actually performs modular exponentiation is algorithm s\_mp\_exptmod. It is a sliding window $k$-ary algorithm 5008which uses Barrett reduction to reduce the product modulo $p$. The second algorithm mp\_exptmod\_fast performs the same operation 5009except it uses either Montgomery or Diminished Radix reduction. The two latter reduction algorithms are clumped in the same exponentiation 5010algorithm since their arguments are essentially the same (\textit{two mp\_ints and one mp\_digit}). 5011 5012\vspace{+3mm}\begin{small} 5013\hspace{-5.1mm}{\bf File}: bn\_mp\_exptmod.c 5014\vspace{-3mm} 5015\begin{alltt} 5016\end{alltt} 5017\end{small} 5018 5019In order to keep the algorithms in a known state the first step on line 29 is to reject any negative modulus as input. If the exponent is 5020negative the algorithm tries to perform a modular exponentiation with the modular inverse of the base $G$. The temporary variable $tmpG$ is assigned 5021the modular inverse of $G$ and $tmpX$ is assigned the absolute value of $X$. The algorithm will recuse with these new values with a positive 5022exponent. 5023 5024If the exponent is positive the algorithm resumes the exponentiation. Line 77 determines if the modulus is of the restricted Diminished Radix 5025form. If it is not line 70 attempts to determine if it is of a unrestricted Diminished Radix form. The integer $dr$ will take on one 5026of three values. 5027 5028\begin{enumerate} 5029\item $dr = 0$ means that the modulus is not of either restricted or unrestricted Diminished Radix form. 5030\item $dr = 1$ means that the modulus is of restricted Diminished Radix form. 5031\item $dr = 2$ means that the modulus is of unrestricted Diminished Radix form. 5032\end{enumerate} 5033 5034Line 69 determines if the fast modular exponentiation algorithm can be used. It is allowed if $dr \ne 0$ or if the modulus is odd. Otherwise, 5035the slower s\_mp\_exptmod algorithm is used which uses Barrett reduction. 5036 5037\subsection{Barrett Modular Exponentiation} 5038 5039\newpage\begin{figure}[!here] 5040\begin{small} 5041\begin{center} 5042\begin{tabular}{l} 5043\hline Algorithm \textbf{s\_mp\_exptmod}. \\ 5044\textbf{Input}. mp\_int $a$, $b$ and $c$ \\ 5045\textbf{Output}. $y \equiv g^x \mbox{ (mod }p\mbox{)}$ \\ 5046\hline \\ 50471. $k \leftarrow lg(x)$ \\ 50482. $winsize \leftarrow \left \lbrace \begin{array}{ll} 5049 2 & \mbox{if }k \le 7 \\ 5050 3 & \mbox{if }7 < k \le 36 \\ 5051 4 & \mbox{if }36 < k \le 140 \\ 5052 5 & \mbox{if }140 < k \le 450 \\ 5053 6 & \mbox{if }450 < k \le 1303 \\ 5054 7 & \mbox{if }1303 < k \le 3529 \\ 5055 8 & \mbox{if }3529 < k \\ 5056 \end{array} \right .$ \\ 50573. Initialize $2^{winsize}$ mp\_ints in an array named $M$ and one mp\_int named $\mu$ \\ 50584. Calculate the $\mu$ required for Barrett Reduction (\textit{mp\_reduce\_setup}). \\ 50595. $M_1 \leftarrow g \mbox{ (mod }p\mbox{)}$ \\ 5060\\ 5061Setup the table of small powers of $g$. First find $g^{2^{winsize}}$ and then all multiples of it. \\ 50626. $k \leftarrow 2^{winsize - 1}$ \\ 50637. $M_{k} \leftarrow M_1$ \\ 50648. for $ix$ from 0 to $winsize - 2$ do \\ 5065\hspace{3mm}8.1 $M_k \leftarrow \left ( M_k \right )^2$ (\textit{mp\_sqr}) \\ 5066\hspace{3mm}8.2 $M_k \leftarrow M_k \mbox{ (mod }p\mbox{)}$ (\textit{mp\_reduce}) \\ 50679. for $ix$ from $2^{winsize - 1} + 1$ to $2^{winsize} - 1$ do \\ 5068\hspace{3mm}9.1 $M_{ix} \leftarrow M_{ix - 1} \cdot M_{1}$ (\textit{mp\_mul}) \\ 5069\hspace{3mm}9.2 $M_{ix} \leftarrow M_{ix} \mbox{ (mod }p\mbox{)}$ (\textit{mp\_reduce}) \\ 507010. $res \leftarrow 1$ \\ 5071\\ 5072Start Sliding Window. \\ 507311. $mode \leftarrow 0, bitcnt \leftarrow 1, buf \leftarrow 0, digidx \leftarrow x.used - 1, bitcpy \leftarrow 0, bitbuf \leftarrow 0$ \\ 507412. Loop \\ 5075\hspace{3mm}12.1 $bitcnt \leftarrow bitcnt - 1$ \\ 5076\hspace{3mm}12.2 If $bitcnt = 0$ then do \\ 5077\hspace{6mm}12.2.1 If $digidx = -1$ goto step 13. \\ 5078\hspace{6mm}12.2.2 $buf \leftarrow x_{digidx}$ \\ 5079\hspace{6mm}12.2.3 $digidx \leftarrow digidx - 1$ \\ 5080\hspace{6mm}12.2.4 $bitcnt \leftarrow lg(\beta)$ \\ 5081Continued on next page. \\ 5082\hline 5083\end{tabular} 5084\end{center} 5085\end{small} 5086\caption{Algorithm s\_mp\_exptmod} 5087\end{figure} 5088 5089\newpage\begin{figure}[!here] 5090\begin{small} 5091\begin{center} 5092\begin{tabular}{l} 5093\hline Algorithm \textbf{s\_mp\_exptmod} (\textit{continued}). \\ 5094\textbf{Input}. mp\_int $a$, $b$ and $c$ \\ 5095\textbf{Output}. $y \equiv g^x \mbox{ (mod }p\mbox{)}$ \\ 5096\hline \\ 5097\hspace{3mm}12.3 $y \leftarrow (buf >> (lg(\beta) - 1))$ AND $1$ \\ 5098\hspace{3mm}12.4 $buf \leftarrow buf << 1$ \\ 5099\hspace{3mm}12.5 if $mode = 0$ and $y = 0$ then goto step 12. \\ 5100\hspace{3mm}12.6 if $mode = 1$ and $y = 0$ then do \\ 5101\hspace{6mm}12.6.1 $res \leftarrow res^2$ \\ 5102\hspace{6mm}12.6.2 $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\ 5103\hspace{6mm}12.6.3 Goto step 12. \\ 5104\hspace{3mm}12.7 $bitcpy \leftarrow bitcpy + 1$ \\ 5105\hspace{3mm}12.8 $bitbuf \leftarrow bitbuf + (y << (winsize - bitcpy))$ \\ 5106\hspace{3mm}12.9 $mode \leftarrow 2$ \\ 5107\hspace{3mm}12.10 If $bitcpy = winsize$ then do \\ 5108\hspace{6mm}Window is full so perform the squarings and single multiplication. \\ 5109\hspace{6mm}12.10.1 for $ix$ from $0$ to $winsize -1$ do \\ 5110\hspace{9mm}12.10.1.1 $res \leftarrow res^2$ \\ 5111\hspace{9mm}12.10.1.2 $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\ 5112\hspace{6mm}12.10.2 $res \leftarrow res \cdot M_{bitbuf}$ \\ 5113\hspace{6mm}12.10.3 $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\ 5114\hspace{6mm}Reset the window. \\ 5115\hspace{6mm}12.10.4 $bitcpy \leftarrow 0, bitbuf \leftarrow 0, mode \leftarrow 1$ \\ 5116\\ 5117No more windows left. Check for residual bits of exponent. \\ 511813. If $mode = 2$ and $bitcpy > 0$ then do \\ 5119\hspace{3mm}13.1 for $ix$ form $0$ to $bitcpy - 1$ do \\ 5120\hspace{6mm}13.1.1 $res \leftarrow res^2$ \\ 5121\hspace{6mm}13.1.2 $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\ 5122\hspace{6mm}13.1.3 $bitbuf \leftarrow bitbuf << 1$ \\ 5123\hspace{6mm}13.1.4 If $bitbuf$ AND $2^{winsize} \ne 0$ then do \\ 5124\hspace{9mm}13.1.4.1 $res \leftarrow res \cdot M_{1}$ \\ 5125\hspace{9mm}13.1.4.2 $res \leftarrow res \mbox{ (mod }p\mbox{)}$ \\ 512614. $y \leftarrow res$ \\ 512715. Clear $res$, $mu$ and the $M$ array. \\ 512816. Return(\textit{MP\_OKAY}). \\ 5129\hline 5130\end{tabular} 5131\end{center} 5132\end{small} 5133\caption{Algorithm s\_mp\_exptmod (continued)} 5134\end{figure} 5135 5136\textbf{Algorithm s\_mp\_exptmod.} 5137This algorithm computes the $x$'th power of $g$ modulo $p$ and stores the result in $y$. It takes advantage of the Barrett reduction 5138algorithm to keep the product small throughout the algorithm. 5139 5140The first two steps determine the optimal window size based on the number of bits in the exponent. The larger the exponent the 5141larger the window size becomes. After a window size $winsize$ has been chosen an array of $2^{winsize}$ mp\_int variables is allocated. This 5142table will hold the values of $g^x \mbox{ (mod }p\mbox{)}$ for $2^{winsize - 1} \le x < 2^{winsize}$. 5143 5144After the table is allocated the first power of $g$ is found. Since $g \ge p$ is allowed it must be first reduced modulo $p$ to make 5145the rest of the algorithm more efficient. The first element of the table at $2^{winsize - 1}$ is found by squaring $M_1$ successively $winsize - 2$ 5146times. The rest of the table elements are found by multiplying the previous element by $M_1$ modulo $p$. 5147 5148Now that the table is available the sliding window may begin. The following list describes the functions of all the variables in the window. 5149\begin{enumerate} 5150\item The variable $mode$ dictates how the bits of the exponent are interpreted. 5151\begin{enumerate} 5152 \item When $mode = 0$ the bits are ignored since no non-zero bit of the exponent has been seen yet. For example, if the exponent were simply 5153 $1$ then there would be $lg(\beta) - 1$ zero bits before the first non-zero bit. In this case bits are ignored until a non-zero bit is found. 5154 \item When $mode = 1$ a non-zero bit has been seen before and a new $winsize$-bit window has not been formed yet. In this mode leading $0$ bits 5155 are read and a single squaring is performed. If a non-zero bit is read a new window is created. 5156 \item When $mode = 2$ the algorithm is in the middle of forming a window and new bits are appended to the window from the most significant bit 5157 downwards. 5158\end{enumerate} 5159\item The variable $bitcnt$ indicates how many bits are left in the current digit of the exponent left to be read. When it reaches zero a new digit 5160 is fetched from the exponent. 5161\item The variable $buf$ holds the currently read digit of the exponent. 5162\item The variable $digidx$ is an index into the exponents digits. It starts at the leading digit $x.used - 1$ and moves towards the trailing digit. 5163\item The variable $bitcpy$ indicates how many bits are in the currently formed window. When it reaches $winsize$ the window is flushed and 5164 the appropriate operations performed. 5165\item The variable $bitbuf$ holds the current bits of the window being formed. 5166\end{enumerate} 5167 5168All of step 12 is the window processing loop. It will iterate while there are digits available form the exponent to read. The first step 5169inside this loop is to extract a new digit if no more bits are available in the current digit. If there are no bits left a new digit is 5170read and if there are no digits left than the loop terminates. 5171 5172After a digit is made available step 12.3 will extract the most significant bit of the current digit and move all other bits in the digit 5173upwards. In effect the digit is read from most significant bit to least significant bit and since the digits are read from leading to 5174trailing edges the entire exponent is read from most significant bit to least significant bit. 5175 5176At step 12.5 if the $mode$ and currently extracted bit $y$ are both zero the bit is ignored and the next bit is read. This prevents the 5177algorithm from having to perform trivial squaring and reduction operations before the first non-zero bit is read. Step 12.6 and 12.7-10 handle 5178the two cases of $mode = 1$ and $mode = 2$ respectively. 5179 5180\begin{center} 5181\begin{figure}[here] 5182\includegraphics{pics/expt_state.ps} 5183\caption{Sliding Window State Diagram} 5184\label{pic:expt_state} 5185\end{figure} 5186\end{center} 5187 5188By step 13 there are no more digits left in the exponent. However, there may be partial bits in the window left. If $mode = 2$ then 5189a Left-to-Right algorithm is used to process the remaining few bits. 5190 5191\vspace{+3mm}\begin{small} 5192\hspace{-5.1mm}{\bf File}: bn\_s\_mp\_exptmod.c 5193\vspace{-3mm} 5194\begin{alltt} 5195\end{alltt} 5196\end{small} 5197 5198Lines 32 through 46 determine the optimal window size based on the length of the exponent in bits. The window divisions are sorted 5199from smallest to greatest so that in each \textbf{if} statement only one condition must be tested. For example, by the \textbf{if} statement 5200on line 38 the value of $x$ is already known to be greater than $140$. 5201 5202The conditional piece of code beginning on line 48 allows the window size to be restricted to five bits. This logic is used to ensure 5203the table of precomputed powers of $G$ remains relatively small. 5204 5205The for loop on line 61 initializes the $M$ array while lines 72 and 77 through 86 initialize the reduction 5206function that will be used for this modulus. 5207 5208-- More later. 5209 5210\section{Quick Power of Two} 5211Calculating $b = 2^a$ can be performed much quicker than with any of the previous algorithms. Recall that a logical shift left $m << k$ is 5212equivalent to $m \cdot 2^k$. By this logic when $m = 1$ a quick power of two can be achieved. 5213 5214\begin{figure}[!here] 5215\begin{small} 5216\begin{center} 5217\begin{tabular}{l} 5218\hline Algorithm \textbf{mp\_2expt}. \\ 5219\textbf{Input}. integer $b$ \\ 5220\textbf{Output}. $a \leftarrow 2^b$ \\ 5221\hline \\ 52221. $a \leftarrow 0$ \\ 52232. If $a.alloc < \lfloor b / lg(\beta) \rfloor + 1$ then grow $a$ appropriately. \\ 52243. $a.used \leftarrow \lfloor b / lg(\beta) \rfloor + 1$ \\ 52254. $a_{\lfloor b / lg(\beta) \rfloor} \leftarrow 1 << (b \mbox{ mod } lg(\beta))$ \\ 52265. Return(\textit{MP\_OKAY}). \\ 5227\hline 5228\end{tabular} 5229\end{center} 5230\end{small} 5231\caption{Algorithm mp\_2expt} 5232\end{figure} 5233 5234\textbf{Algorithm mp\_2expt.} 5235 5236\vspace{+3mm}\begin{small} 5237\hspace{-5.1mm}{\bf File}: bn\_mp\_2expt.c 5238\vspace{-3mm} 5239\begin{alltt} 5240\end{alltt} 5241\end{small} 5242 5243\chapter{Higher Level Algorithms} 5244 5245This chapter discusses the various higher level algorithms that are required to complete a well rounded multiple precision integer package. These 5246routines are less performance oriented than the algorithms of chapters five, six and seven but are no less important. 5247 5248The first section describes a method of integer division with remainder that is universally well known. It provides the signed division logic 5249for the package. The subsequent section discusses a set of algorithms which allow a single digit to be the 2nd operand for a variety of operations. 5250These algorithms serve mostly to simplify other algorithms where small constants are required. The last two sections discuss how to manipulate 5251various representations of integers. For example, converting from an mp\_int to a string of character. 5252 5253\section{Integer Division with Remainder} 5254\label{sec:division} 5255 5256Integer division aside from modular exponentiation is the most intensive algorithm to compute. Like addition, subtraction and multiplication 5257the basis of this algorithm is the long-hand division algorithm taught to school children. Throughout this discussion several common variables 5258will be used. Let $x$ represent the divisor and $y$ represent the dividend. Let $q$ represent the integer quotient $\lfloor y / x \rfloor$ and 5259let $r$ represent the remainder $r = y - x \lfloor y / x \rfloor$. The following simple algorithm will be used to start the discussion. 5260 5261\newpage\begin{figure}[!here] 5262\begin{small} 5263\begin{center} 5264\begin{tabular}{l} 5265\hline Algorithm \textbf{Radix-$\beta$ Integer Division}. \\ 5266\textbf{Input}. integer $x$ and $y$ \\ 5267\textbf{Output}. $q = \lfloor y/x\rfloor, r = y - xq$ \\ 5268\hline \\ 52691. $q \leftarrow 0$ \\ 52702. $n \leftarrow \vert \vert y \vert \vert - \vert \vert x \vert \vert$ \\ 52713. for $t$ from $n$ down to $0$ do \\ 5272\hspace{3mm}3.1 Maximize $k$ such that $kx\beta^t$ is less than or equal to $y$ and $(k + 1)x\beta^t$ is greater. \\ 5273\hspace{3mm}3.2 $q \leftarrow q + k\beta^t$ \\ 5274\hspace{3mm}3.3 $y \leftarrow y - kx\beta^t$ \\ 52754. $r \leftarrow y$ \\ 52765. Return($q, r$) \\ 5277\hline 5278\end{tabular} 5279\end{center} 5280\end{small} 5281\caption{Algorithm Radix-$\beta$ Integer Division} 5282\label{fig:raddiv} 5283\end{figure} 5284 5285As children we are taught this very simple algorithm for the case of $\beta = 10$. Almost instinctively several optimizations are taught for which 5286their reason of existing are never explained. For this example let $y = 5471$ represent the dividend and $x = 23$ represent the divisor. 5287 5288To find the first digit of the quotient the value of $k$ must be maximized such that $kx\beta^t$ is less than or equal to $y$ and 5289simultaneously $(k + 1)x\beta^t$ is greater than $y$. Implicitly $k$ is the maximum value the $t$'th digit of the quotient may have. The habitual method 5290used to find the maximum is to ``eyeball'' the two numbers, typically only the leading digits and quickly estimate a quotient. By only using leading 5291digits a much simpler division may be used to form an educated guess at what the value must be. In this case $k = \lfloor 54/23\rfloor = 2$ quickly 5292arises as a possible solution. Indeed $2x\beta^2 = 4600$ is less than $y = 5471$ and simultaneously $(k + 1)x\beta^2 = 6900$ is larger than $y$. 5293As a result $k\beta^2$ is added to the quotient which now equals $q = 200$ and $4600$ is subtracted from $y$ to give a remainder of $y = 841$. 5294 5295Again this process is repeated to produce the quotient digit $k = 3$ which makes the quotient $q = 200 + 3\beta = 230$ and the remainder 5296$y = 841 - 3x\beta = 181$. Finally the last iteration of the loop produces $k = 7$ which leads to the quotient $q = 230 + 7 = 237$ and the 5297remainder $y = 181 - 7x = 20$. The final quotient and remainder found are $q = 237$ and $r = y = 20$ which are indeed correct since 5298$237 \cdot 23 + 20 = 5471$ is true. 5299 5300\subsection{Quotient Estimation} 5301\label{sec:divest} 5302As alluded to earlier the quotient digit $k$ can be estimated from only the leading digits of both the divisor and dividend. When $p$ leading 5303digits are used from both the divisor and dividend to form an estimation the accuracy of the estimation rises as $p$ grows. Technically 5304speaking the estimation is based on assuming the lower $\vert \vert y \vert \vert - p$ and $\vert \vert x \vert \vert - p$ lower digits of the 5305dividend and divisor are zero. 5306 5307The value of the estimation may off by a few values in either direction and in general is fairly correct. A simplification \cite[pp. 271]{TAOCPV2} 5308of the estimation technique is to use $t + 1$ digits of the dividend and $t$ digits of the divisor, in particularly when $t = 1$. The estimate 5309using this technique is never too small. For the following proof let $t = \vert \vert y \vert \vert - 1$ and $s = \vert \vert x \vert \vert - 1$ 5310represent the most significant digits of the dividend and divisor respectively. 5311 5312\textbf{Proof.}\textit{ The quotient $\hat k = \lfloor (y_t\beta + y_{t-1}) / x_s \rfloor$ is greater than or equal to 5313$k = \lfloor y / (x \cdot \beta^{\vert \vert y \vert \vert - \vert \vert x \vert \vert - 1}) \rfloor$. } 5314The first obvious case is when $\hat k = \beta - 1$ in which case the proof is concluded since the real quotient cannot be larger. For all other 5315cases $\hat k = \lfloor (y_t\beta + y_{t-1}) / x_s \rfloor$ and $\hat k x_s \ge y_t\beta + y_{t-1} - x_s + 1$. The latter portion of the inequalility 5316$-x_s + 1$ arises from the fact that a truncated integer division will give the same quotient for at most $x_s - 1$ values. Next a series of 5317inequalities will prove the hypothesis. 5318 5319\begin{equation} 5320y - \hat k x \le y - \hat k x_s\beta^s 5321\end{equation} 5322 5323This is trivially true since $x \ge x_s\beta^s$. Next we replace $\hat kx_s\beta^s$ by the previous inequality for $\hat kx_s$. 5324 5325\begin{equation} 5326y - \hat k x \le y_t\beta^t + \ldots + y_0 - (y_t\beta^t + y_{t-1}\beta^{t-1} - x_s\beta^t + \beta^s) 5327\end{equation} 5328 5329By simplifying the previous inequality the following inequality is formed. 5330 5331\begin{equation} 5332y - \hat k x \le y_{t-2}\beta^{t-2} + \ldots + y_0 + x_s\beta^s - \beta^s 5333\end{equation} 5334 5335Subsequently, 5336 5337\begin{equation} 5338y_{t-2}\beta^{t-2} + \ldots + y_0 + x_s\beta^s - \beta^s < x_s\beta^s \le x 5339\end{equation} 5340 5341Which proves that $y - \hat kx \le x$ and by consequence $\hat k \ge k$ which concludes the proof. \textbf{QED} 5342 5343 5344\subsection{Normalized Integers} 5345For the purposes of division a normalized input is when the divisors leading digit $x_n$ is greater than or equal to $\beta / 2$. By multiplying both 5346$x$ and $y$ by $j = \lfloor (\beta / 2) / x_n \rfloor$ the quotient remains unchanged and the remainder is simply $j$ times the original 5347remainder. The purpose of normalization is to ensure the leading digit of the divisor is sufficiently large such that the estimated quotient will 5348lie in the domain of a single digit. Consider the maximum dividend $(\beta - 1) \cdot \beta + (\beta - 1)$ and the minimum divisor $\beta / 2$. 5349 5350\begin{equation} 5351{{\beta^2 - 1} \over { \beta / 2}} \le 2\beta - {2 \over \beta} 5352\end{equation} 5353 5354At most the quotient approaches $2\beta$, however, in practice this will not occur since that would imply the previous quotient digit was too small. 5355 5356\subsection{Radix-$\beta$ Division with Remainder} 5357\newpage\begin{figure}[!here] 5358\begin{small} 5359\begin{center} 5360\begin{tabular}{l} 5361\hline Algorithm \textbf{mp\_div}. \\ 5362\textbf{Input}. mp\_int $a, b$ \\ 5363\textbf{Output}. $c = \lfloor a/b \rfloor$, $d = a - bc$ \\ 5364\hline \\ 53651. If $b = 0$ return(\textit{MP\_VAL}). \\ 53662. If $\vert a \vert < \vert b \vert$ then do \\ 5367\hspace{3mm}2.1 $d \leftarrow a$ \\ 5368\hspace{3mm}2.2 $c \leftarrow 0$ \\ 5369\hspace{3mm}2.3 Return(\textit{MP\_OKAY}). \\ 5370\\ 5371Setup the quotient to receive the digits. \\ 53723. Grow $q$ to $a.used + 2$ digits. \\ 53734. $q \leftarrow 0$ \\ 53745. $x \leftarrow \vert a \vert , y \leftarrow \vert b \vert$ \\ 53756. $sign \leftarrow \left \lbrace \begin{array}{ll} 5376 MP\_ZPOS & \mbox{if }a.sign = b.sign \\ 5377 MP\_NEG & \mbox{otherwise} \\ 5378 \end{array} \right .$ \\ 5379\\ 5380Normalize the inputs such that the leading digit of $y$ is greater than or equal to $\beta / 2$. \\ 53817. $norm \leftarrow (lg(\beta) - 1) - (\lceil lg(y) \rceil \mbox{ (mod }lg(\beta)\mbox{)})$ \\ 53828. $x \leftarrow x \cdot 2^{norm}, y \leftarrow y \cdot 2^{norm}$ \\ 5383\\ 5384Find the leading digit of the quotient. \\ 53859. $n \leftarrow x.used - 1, t \leftarrow y.used - 1$ \\ 538610. $y \leftarrow y \cdot \beta^{n - t}$ \\ 538711. While ($x \ge y$) do \\ 5388\hspace{3mm}11.1 $q_{n - t} \leftarrow q_{n - t} + 1$ \\ 5389\hspace{3mm}11.2 $x \leftarrow x - y$ \\ 539012. $y \leftarrow \lfloor y / \beta^{n-t} \rfloor$ \\ 5391\\ 5392Continued on the next page. \\ 5393\hline 5394\end{tabular} 5395\end{center} 5396\end{small} 5397\caption{Algorithm mp\_div} 5398\end{figure} 5399 5400\newpage\begin{figure}[!here] 5401\begin{small} 5402\begin{center} 5403\begin{tabular}{l} 5404\hline Algorithm \textbf{mp\_div} (continued). \\ 5405\textbf{Input}. mp\_int $a, b$ \\ 5406\textbf{Output}. $c = \lfloor a/b \rfloor$, $d = a - bc$ \\ 5407\hline \\ 5408Now find the remainder fo the digits. \\ 540913. for $i$ from $n$ down to $(t + 1)$ do \\ 5410\hspace{3mm}13.1 If $i > x.used$ then jump to the next iteration of this loop. \\ 5411\hspace{3mm}13.2 If $x_{i} = y_{t}$ then \\ 5412\hspace{6mm}13.2.1 $q_{i - t - 1} \leftarrow \beta - 1$ \\ 5413\hspace{3mm}13.3 else \\ 5414\hspace{6mm}13.3.1 $\hat r \leftarrow x_{i} \cdot \beta + x_{i - 1}$ \\ 5415\hspace{6mm}13.3.2 $\hat r \leftarrow \lfloor \hat r / y_{t} \rfloor$ \\ 5416\hspace{6mm}13.3.3 $q_{i - t - 1} \leftarrow \hat r$ \\ 5417\hspace{3mm}13.4 $q_{i - t - 1} \leftarrow q_{i - t - 1} + 1$ \\ 5418\\ 5419Fixup quotient estimation. \\ 5420\hspace{3mm}13.5 Loop \\ 5421\hspace{6mm}13.5.1 $q_{i - t - 1} \leftarrow q_{i - t - 1} - 1$ \\ 5422\hspace{6mm}13.5.2 t$1 \leftarrow 0$ \\ 5423\hspace{6mm}13.5.3 t$1_0 \leftarrow y_{t - 1}, $ t$1_1 \leftarrow y_t,$ t$1.used \leftarrow 2$ \\ 5424\hspace{6mm}13.5.4 $t1 \leftarrow t1 \cdot q_{i - t - 1}$ \\ 5425\hspace{6mm}13.5.5 t$2_0 \leftarrow x_{i - 2}, $ t$2_1 \leftarrow x_{i - 1}, $ t$2_2 \leftarrow x_i, $ t$2.used \leftarrow 3$ \\ 5426\hspace{6mm}13.5.6 If $\vert t1 \vert > \vert t2 \vert$ then goto step 13.5. \\ 5427\hspace{3mm}13.6 t$1 \leftarrow y \cdot q_{i - t - 1}$ \\ 5428\hspace{3mm}13.7 t$1 \leftarrow $ t$1 \cdot \beta^{i - t - 1}$ \\ 5429\hspace{3mm}13.8 $x \leftarrow x - $ t$1$ \\ 5430\hspace{3mm}13.9 If $x.sign = MP\_NEG$ then \\ 5431\hspace{6mm}13.10 t$1 \leftarrow y$ \\ 5432\hspace{6mm}13.11 t$1 \leftarrow $ t$1 \cdot \beta^{i - t - 1}$ \\ 5433\hspace{6mm}13.12 $x \leftarrow x + $ t$1$ \\ 5434\hspace{6mm}13.13 $q_{i - t - 1} \leftarrow q_{i - t - 1} - 1$ \\ 5435\\ 5436Finalize the result. \\ 543714. Clamp excess digits of $q$ \\ 543815. $c \leftarrow q, c.sign \leftarrow sign$ \\ 543916. $x.sign \leftarrow a.sign$ \\ 544017. $d \leftarrow \lfloor x / 2^{norm} \rfloor$ \\ 544118. Return(\textit{MP\_OKAY}). \\ 5442\hline 5443\end{tabular} 5444\end{center} 5445\end{small} 5446\caption{Algorithm mp\_div (continued)} 5447\end{figure} 5448\textbf{Algorithm mp\_div.} 5449This algorithm will calculate quotient and remainder from an integer division given a dividend and divisor. The algorithm is a signed 5450division and will produce a fully qualified quotient and remainder. 5451 5452First the divisor $b$ must be non-zero which is enforced in step one. If the divisor is larger than the dividend than the quotient is implicitly 5453zero and the remainder is the dividend. 5454 5455After the first two trivial cases of inputs are handled the variable $q$ is setup to receive the digits of the quotient. Two unsigned copies of the 5456divisor $y$ and dividend $x$ are made as well. The core of the division algorithm is an unsigned division and will only work if the values are 5457positive. Now the two values $x$ and $y$ must be normalized such that the leading digit of $y$ is greater than or equal to $\beta / 2$. 5458This is performed by shifting both to the left by enough bits to get the desired normalization. 5459 5460At this point the division algorithm can begin producing digits of the quotient. Recall that maximum value of the estimation used is 5461$2\beta - {2 \over \beta}$ which means that a digit of the quotient must be first produced by another means. In this case $y$ is shifted 5462to the left (\textit{step ten}) so that it has the same number of digits as $x$. The loop on step eleven will subtract multiples of the 5463shifted copy of $y$ until $x$ is smaller. Since the leading digit of $y$ is greater than or equal to $\beta/2$ this loop will iterate at most two 5464times to produce the desired leading digit of the quotient. 5465 5466Now the remainder of the digits can be produced. The equation $\hat q = \lfloor {{x_i \beta + x_{i-1}}\over y_t} \rfloor$ is used to fairly 5467accurately approximate the true quotient digit. The estimation can in theory produce an estimation as high as $2\beta - {2 \over \beta}$ but by 5468induction the upper quotient digit is correct (\textit{as established on step eleven}) and the estimate must be less than $\beta$. 5469 5470Recall from section~\ref{sec:divest} that the estimation is never too low but may be too high. The next step of the estimation process is 5471to refine the estimation. The loop on step 13.5 uses $x_i\beta^2 + x_{i-1}\beta + x_{i-2}$ and $q_{i - t - 1}(y_t\beta + y_{t-1})$ as a higher 5472order approximation to adjust the quotient digit. 5473 5474After both phases of estimation the quotient digit may still be off by a value of one\footnote{This is similar to the error introduced 5475by optimizing Barrett reduction.}. Steps 13.6 and 13.7 subtract the multiple of the divisor from the dividend (\textit{Similar to step 3.3 of 5476algorithm~\ref{fig:raddiv}} and then subsequently add a multiple of the divisor if the quotient was too large. 5477 5478Now that the quotient has been determine finializing the result is a matter of clamping the quotient, fixing the sizes and de-normalizing the 5479remainder. An important aspect of this algorithm seemingly overlooked in other descriptions such as that of Algorithm 14.20 HAC \cite[pp. 598]{HAC} 5480is that when the estimations are being made (\textit{inside the loop on step 13.5}) that the digits $y_{t-1}$, $x_{i-2}$ and $x_{i-1}$ may lie 5481outside their respective boundaries. For example, if $t = 0$ or $i \le 1$ then the digits would be undefined. In those cases the digits should 5482respectively be replaced with a zero. 5483 5484\vspace{+3mm}\begin{small} 5485\hspace{-5.1mm}{\bf File}: bn\_mp\_div.c 5486\vspace{-3mm} 5487\begin{alltt} 5488\end{alltt} 5489\end{small} 5490 5491The implementation of this algorithm differs slightly from the pseudo code presented previously. In this algorithm either of the quotient $c$ or 5492remainder $d$ may be passed as a \textbf{NULL} pointer which indicates their value is not desired. For example, the C code to call the division 5493algorithm with only the quotient is 5494 5495\begin{verbatim} 5496mp_div(&a, &b, &c, NULL); /* c = [a/b] */ 5497\end{verbatim} 5498 5499Lines 109 and 113 handle the two trivial cases of inputs which are division by zero and dividend smaller than the divisor 5500respectively. After the two trivial cases all of the temporary variables are initialized. Line 148 determines the sign of 5501the quotient and line 148 ensures that both $x$ and $y$ are positive. 5502 5503The number of bits in the leading digit is calculated on line 151. Implictly an mp\_int with $r$ digits will require $lg(\beta)(r-1) + k$ bits 5504of precision which when reduced modulo $lg(\beta)$ produces the value of $k$. In this case $k$ is the number of bits in the leading digit which is 5505exactly what is required. For the algorithm to operate $k$ must equal $lg(\beta) - 1$ and when it does not the inputs must be normalized by shifting 5506them to the left by $lg(\beta) - 1 - k$ bits. 5507 5508Throughout the variables $n$ and $t$ will represent the highest digit of $x$ and $y$ respectively. These are first used to produce the 5509leading digit of the quotient. The loop beginning on line 184 will produce the remainder of the quotient digits. 5510 5511The conditional ``continue'' on line 187 is used to prevent the algorithm from reading past the leading edge of $x$ which can occur when the 5512algorithm eliminates multiple non-zero digits in a single iteration. This ensures that $x_i$ is always non-zero since by definition the digits 5513above the $i$'th position $x$ must be zero in order for the quotient to be precise\footnote{Precise as far as integer division is concerned.}. 5514 5515Lines 214, 216 and 223 through 225 manually construct the high accuracy estimations by setting the digits of the two mp\_int 5516variables directly. 5517 5518\section{Single Digit Helpers} 5519 5520This section briefly describes a series of single digit helper algorithms which come in handy when working with small constants. All of 5521the helper functions assume the single digit input is positive and will treat them as such. 5522 5523\subsection{Single Digit Addition and Subtraction} 5524 5525Both addition and subtraction are performed by ``cheating'' and using mp\_set followed by the higher level addition or subtraction 5526algorithms. As a result these algorithms are subtantially simpler with a slight cost in performance. 5527 5528\newpage\begin{figure}[!here] 5529\begin{small} 5530\begin{center} 5531\begin{tabular}{l} 5532\hline Algorithm \textbf{mp\_add\_d}. \\ 5533\textbf{Input}. mp\_int $a$ and a mp\_digit $b$ \\ 5534\textbf{Output}. $c = a + b$ \\ 5535\hline \\ 55361. $t \leftarrow b$ (\textit{mp\_set}) \\ 55372. $c \leftarrow a + t$ \\ 55383. Return(\textit{MP\_OKAY}) \\ 5539\hline 5540\end{tabular} 5541\end{center} 5542\end{small} 5543\caption{Algorithm mp\_add\_d} 5544\end{figure} 5545 5546\textbf{Algorithm mp\_add\_d.} 5547This algorithm initiates a temporary mp\_int with the value of the single digit and uses algorithm mp\_add to add the two values together. 5548 5549\vspace{+3mm}\begin{small} 5550\hspace{-5.1mm}{\bf File}: bn\_mp\_add\_d.c 5551\vspace{-3mm} 5552\begin{alltt} 5553\end{alltt} 5554\end{small} 5555 5556Clever use of the letter 't'. 5557 5558\subsubsection{Subtraction} 5559The single digit subtraction algorithm mp\_sub\_d is essentially the same except it uses mp\_sub to subtract the digit from the mp\_int. 5560 5561\subsection{Single Digit Multiplication} 5562Single digit multiplication arises enough in division and radix conversion that it ought to be implement as a special case of the baseline 5563multiplication algorithm. Essentially this algorithm is a modified version of algorithm s\_mp\_mul\_digs where one of the multiplicands 5564only has one digit. 5565 5566\begin{figure}[!here] 5567\begin{small} 5568\begin{center} 5569\begin{tabular}{l} 5570\hline Algorithm \textbf{mp\_mul\_d}. \\ 5571\textbf{Input}. mp\_int $a$ and a mp\_digit $b$ \\ 5572\textbf{Output}. $c = ab$ \\ 5573\hline \\ 55741. $pa \leftarrow a.used$ \\ 55752. Grow $c$ to at least $pa + 1$ digits. \\ 55763. $oldused \leftarrow c.used$ \\ 55774. $c.used \leftarrow pa + 1$ \\ 55785. $c.sign \leftarrow a.sign$ \\ 55796. $\mu \leftarrow 0$ \\ 55807. for $ix$ from $0$ to $pa - 1$ do \\ 5581\hspace{3mm}7.1 $\hat r \leftarrow \mu + a_{ix}b$ \\ 5582\hspace{3mm}7.2 $c_{ix} \leftarrow \hat r \mbox{ (mod }\beta\mbox{)}$ \\ 5583\hspace{3mm}7.3 $\mu \leftarrow \lfloor \hat r / \beta \rfloor$ \\ 55848. $c_{pa} \leftarrow \mu$ \\ 55859. for $ix$ from $pa + 1$ to $oldused$ do \\ 5586\hspace{3mm}9.1 $c_{ix} \leftarrow 0$ \\ 558710. Clamp excess digits of $c$. \\ 558811. Return(\textit{MP\_OKAY}). \\ 5589\hline 5590\end{tabular} 5591\end{center} 5592\end{small} 5593\caption{Algorithm mp\_mul\_d} 5594\end{figure} 5595\textbf{Algorithm mp\_mul\_d.} 5596This algorithm quickly multiplies an mp\_int by a small single digit value. It is specially tailored to the job and has a minimal of overhead. 5597Unlike the full multiplication algorithms this algorithm does not require any significnat temporary storage or memory allocations. 5598 5599\vspace{+3mm}\begin{small} 5600\hspace{-5.1mm}{\bf File}: bn\_mp\_mul\_d.c 5601\vspace{-3mm} 5602\begin{alltt} 5603\end{alltt} 5604\end{small} 5605 5606In this implementation the destination $c$ may point to the same mp\_int as the source $a$ since the result is written after the digit is 5607read from the source. This function uses pointer aliases $tmpa$ and $tmpc$ for the digits of $a$ and $c$ respectively. 5608 5609\subsection{Single Digit Division} 5610Like the single digit multiplication algorithm, single digit division is also a fairly common algorithm used in radix conversion. Since the 5611divisor is only a single digit a specialized variant of the division algorithm can be used to compute the quotient. 5612 5613\newpage\begin{figure}[!here] 5614\begin{small} 5615\begin{center} 5616\begin{tabular}{l} 5617\hline Algorithm \textbf{mp\_div\_d}. \\ 5618\textbf{Input}. mp\_int $a$ and a mp\_digit $b$ \\ 5619\textbf{Output}. $c = \lfloor a / b \rfloor, d = a - cb$ \\ 5620\hline \\ 56211. If $b = 0$ then return(\textit{MP\_VAL}).\\ 56222. If $b = 3$ then use algorithm mp\_div\_3 instead. \\ 56233. Init $q$ to $a.used$ digits. \\ 56244. $q.used \leftarrow a.used$ \\ 56255. $q.sign \leftarrow a.sign$ \\ 56266. $\hat w \leftarrow 0$ \\ 56277. for $ix$ from $a.used - 1$ down to $0$ do \\ 5628\hspace{3mm}7.1 $\hat w \leftarrow \hat w \beta + a_{ix}$ \\ 5629\hspace{3mm}7.2 If $\hat w \ge b$ then \\ 5630\hspace{6mm}7.2.1 $t \leftarrow \lfloor \hat w / b \rfloor$ \\ 5631\hspace{6mm}7.2.2 $\hat w \leftarrow \hat w \mbox{ (mod }b\mbox{)}$ \\ 5632\hspace{3mm}7.3 else\\ 5633\hspace{6mm}7.3.1 $t \leftarrow 0$ \\ 5634\hspace{3mm}7.4 $q_{ix} \leftarrow t$ \\ 56358. $d \leftarrow \hat w$ \\ 56369. Clamp excess digits of $q$. \\ 563710. $c \leftarrow q$ \\ 563811. Return(\textit{MP\_OKAY}). \\ 5639\hline 5640\end{tabular} 5641\end{center} 5642\end{small} 5643\caption{Algorithm mp\_div\_d} 5644\end{figure} 5645\textbf{Algorithm mp\_div\_d.} 5646This algorithm divides the mp\_int $a$ by the single mp\_digit $b$ using an optimized approach. Essentially in every iteration of the 5647algorithm another digit of the dividend is reduced and another digit of quotient produced. Provided $b < \beta$ the value of $\hat w$ 5648after step 7.1 will be limited such that $0 \le \lfloor \hat w / b \rfloor < \beta$. 5649 5650If the divisor $b$ is equal to three a variant of this algorithm is used which is called mp\_div\_3. It replaces the division by three with 5651a multiplication by $\lfloor \beta / 3 \rfloor$ and the appropriate shift and residual fixup. In essence it is much like the Barrett reduction 5652from chapter seven. 5653 5654\vspace{+3mm}\begin{small} 5655\hspace{-5.1mm}{\bf File}: bn\_mp\_div\_d.c 5656\vspace{-3mm} 5657\begin{alltt} 5658\end{alltt} 5659\end{small} 5660 5661Like the implementation of algorithm mp\_div this algorithm allows either of the quotient or remainder to be passed as a \textbf{NULL} pointer to 5662indicate the respective value is not required. This allows a trivial single digit modular reduction algorithm, mp\_mod\_d to be created. 5663 5664The division and remainder on lines 44 and @45,%@ can be replaced often by a single division on most processors. For example, the 32-bit x86 based 5665processors can divide a 64-bit quantity by a 32-bit quantity and produce the quotient and remainder simultaneously. Unfortunately the GCC 5666compiler does not recognize that optimization and will actually produce two function calls to find the quotient and remainder respectively. 5667 5668\subsection{Single Digit Root Extraction} 5669 5670Finding the $n$'th root of an integer is fairly easy as far as numerical analysis is concerned. Algorithms such as the Newton-Raphson approximation 5671(\ref{eqn:newton}) series will converge very quickly to a root for any continuous function $f(x)$. 5672 5673\begin{equation} 5674x_{i+1} = x_i - {f(x_i) \over f'(x_i)} 5675\label{eqn:newton} 5676\end{equation} 5677 5678In this case the $n$'th root is desired and $f(x) = x^n - a$ where $a$ is the integer of which the root is desired. The derivative of $f(x)$ is 5679simply $f'(x) = nx^{n - 1}$. Of particular importance is that this algorithm will be used over the integers not over the a more continuous domain 5680such as the real numbers. As a result the root found can be above the true root by few and must be manually adjusted. Ideally at the end of the 5681algorithm the $n$'th root $b$ of an integer $a$ is desired such that $b^n \le a$. 5682 5683\newpage\begin{figure}[!here] 5684\begin{small} 5685\begin{center} 5686\begin{tabular}{l} 5687\hline Algorithm \textbf{mp\_n\_root}. \\ 5688\textbf{Input}. mp\_int $a$ and a mp\_digit $b$ \\ 5689\textbf{Output}. $c^b \le a$ \\ 5690\hline \\ 56911. If $b$ is even and $a.sign = MP\_NEG$ return(\textit{MP\_VAL}). \\ 56922. $sign \leftarrow a.sign$ \\ 56933. $a.sign \leftarrow MP\_ZPOS$ \\ 56944. t$2 \leftarrow 2$ \\ 56955. Loop \\ 5696\hspace{3mm}5.1 t$1 \leftarrow $ t$2$ \\ 5697\hspace{3mm}5.2 t$3 \leftarrow $ t$1^{b - 1}$ \\ 5698\hspace{3mm}5.3 t$2 \leftarrow $ t$3 $ $\cdot$ t$1$ \\ 5699\hspace{3mm}5.4 t$2 \leftarrow $ t$2 - a$ \\ 5700\hspace{3mm}5.5 t$3 \leftarrow $ t$3 \cdot b$ \\ 5701\hspace{3mm}5.6 t$3 \leftarrow \lfloor $t$2 / $t$3 \rfloor$ \\ 5702\hspace{3mm}5.7 t$2 \leftarrow $ t$1 - $ t$3$ \\ 5703\hspace{3mm}5.8 If t$1 \ne $ t$2$ then goto step 5. \\ 57046. Loop \\ 5705\hspace{3mm}6.1 t$2 \leftarrow $ t$1^b$ \\ 5706\hspace{3mm}6.2 If t$2 > a$ then \\ 5707\hspace{6mm}6.2.1 t$1 \leftarrow $ t$1 - 1$ \\ 5708\hspace{6mm}6.2.2 Goto step 6. \\ 57097. $a.sign \leftarrow sign$ \\ 57108. $c \leftarrow $ t$1$ \\ 57119. $c.sign \leftarrow sign$ \\ 571210. Return(\textit{MP\_OKAY}). \\ 5713\hline 5714\end{tabular} 5715\end{center} 5716\end{small} 5717\caption{Algorithm mp\_n\_root} 5718\end{figure} 5719\textbf{Algorithm mp\_n\_root.} 5720This algorithm finds the integer $n$'th root of an input using the Newton-Raphson approach. It is partially optimized based on the observation 5721that the numerator of ${f(x) \over f'(x)}$ can be derived from a partial denominator. That is at first the denominator is calculated by finding 5722$x^{b - 1}$. This value can then be multiplied by $x$ and have $a$ subtracted from it to find the numerator. This saves a total of $b - 1$ 5723multiplications by t$1$ inside the loop. 5724 5725The initial value of the approximation is t$2 = 2$ which allows the algorithm to start with very small values and quickly converge on the 5726root. Ideally this algorithm is meant to find the $n$'th root of an input where $n$ is bounded by $2 \le n \le 5$. 5727 5728\vspace{+3mm}\begin{small} 5729\hspace{-5.1mm}{\bf File}: bn\_mp\_n\_root.c 5730\vspace{-3mm} 5731\begin{alltt} 5732\end{alltt} 5733\end{small} 5734 5735\section{Random Number Generation} 5736 5737Random numbers come up in a variety of activities from public key cryptography to simple simulations and various randomized algorithms. Pollard-Rho 5738factoring for example, can make use of random values as starting points to find factors of a composite integer. In this case the algorithm presented 5739is solely for simulations and not intended for cryptographic use. 5740 5741\newpage\begin{figure}[!here] 5742\begin{small} 5743\begin{center} 5744\begin{tabular}{l} 5745\hline Algorithm \textbf{mp\_rand}. \\ 5746\textbf{Input}. An integer $b$ \\ 5747\textbf{Output}. A pseudo-random number of $b$ digits \\ 5748\hline \\ 57491. $a \leftarrow 0$ \\ 57502. If $b \le 0$ return(\textit{MP\_OKAY}) \\ 57513. Pick a non-zero random digit $d$. \\ 57524. $a \leftarrow a + d$ \\ 57535. for $ix$ from 1 to $d - 1$ do \\ 5754\hspace{3mm}5.1 $a \leftarrow a \cdot \beta$ \\ 5755\hspace{3mm}5.2 Pick a random digit $d$. \\ 5756\hspace{3mm}5.3 $a \leftarrow a + d$ \\ 57576. Return(\textit{MP\_OKAY}). \\ 5758\hline 5759\end{tabular} 5760\end{center} 5761\end{small} 5762\caption{Algorithm mp\_rand} 5763\end{figure} 5764\textbf{Algorithm mp\_rand.} 5765This algorithm produces a pseudo-random integer of $b$ digits. By ensuring that the first digit is non-zero the algorithm also guarantees that the 5766final result has at least $b$ digits. It relies heavily on a third-part random number generator which should ideally generate uniformly all of 5767the integers from $0$ to $\beta - 1$. 5768 5769\vspace{+3mm}\begin{small} 5770\hspace{-5.1mm}{\bf File}: bn\_mp\_rand.c 5771\vspace{-3mm} 5772\begin{alltt} 5773\end{alltt} 5774\end{small} 5775 5776\section{Formatted Representations} 5777The ability to emit a radix-$n$ textual representation of an integer is useful for interacting with human parties. For example, the ability to 5778be given a string of characters such as ``114585'' and turn it into the radix-$\beta$ equivalent would make it easier to enter numbers 5779into a program. 5780 5781\subsection{Reading Radix-n Input} 5782For the purposes of this text we will assume that a simple lower ASCII map (\ref{fig:ASC}) is used for the values of from $0$ to $63$ to 5783printable characters. For example, when the character ``N'' is read it represents the integer $23$. The first $16$ characters of the 5784map are for the common representations up to hexadecimal. After that they match the ``base64'' encoding scheme which are suitable chosen 5785such that they are printable. While outputting as base64 may not be too helpful for human operators it does allow communication via non binary 5786mediums. 5787 5788\newpage\begin{figure}[here] 5789\begin{center} 5790\begin{tabular}{cc|cc|cc|cc} 5791\hline \textbf{Value} & \textbf{Char} & \textbf{Value} & \textbf{Char} & \textbf{Value} & \textbf{Char} & \textbf{Value} & \textbf{Char} \\ 5792\hline 57930 & 0 & 1 & 1 & 2 & 2 & 3 & 3 \\ 57944 & 4 & 5 & 5 & 6 & 6 & 7 & 7 \\ 57958 & 8 & 9 & 9 & 10 & A & 11 & B \\ 579612 & C & 13 & D & 14 & E & 15 & F \\ 579716 & G & 17 & H & 18 & I & 19 & J \\ 579820 & K & 21 & L & 22 & M & 23 & N \\ 579924 & O & 25 & P & 26 & Q & 27 & R \\ 580028 & S & 29 & T & 30 & U & 31 & V \\ 580132 & W & 33 & X & 34 & Y & 35 & Z \\ 580236 & a & 37 & b & 38 & c & 39 & d \\ 580340 & e & 41 & f & 42 & g & 43 & h \\ 580444 & i & 45 & j & 46 & k & 47 & l \\ 580548 & m & 49 & n & 50 & o & 51 & p \\ 580652 & q & 53 & r & 54 & s & 55 & t \\ 580756 & u & 57 & v & 58 & w & 59 & x \\ 580860 & y & 61 & z & 62 & $+$ & 63 & $/$ \\ 5809\hline 5810\end{tabular} 5811\end{center} 5812\caption{Lower ASCII Map} 5813\label{fig:ASC} 5814\end{figure} 5815 5816\newpage\begin{figure}[!here] 5817\begin{small} 5818\begin{center} 5819\begin{tabular}{l} 5820\hline Algorithm \textbf{mp\_read\_radix}. \\ 5821\textbf{Input}. A string $str$ of length $sn$ and radix $r$. \\ 5822\textbf{Output}. The radix-$\beta$ equivalent mp\_int. \\ 5823\hline \\ 58241. If $r < 2$ or $r > 64$ return(\textit{MP\_VAL}). \\ 58252. $ix \leftarrow 0$ \\ 58263. If $str_0 =$ ``-'' then do \\ 5827\hspace{3mm}3.1 $ix \leftarrow ix + 1$ \\ 5828\hspace{3mm}3.2 $sign \leftarrow MP\_NEG$ \\ 58294. else \\ 5830\hspace{3mm}4.1 $sign \leftarrow MP\_ZPOS$ \\ 58315. $a \leftarrow 0$ \\ 58326. for $iy$ from $ix$ to $sn - 1$ do \\ 5833\hspace{3mm}6.1 Let $y$ denote the position in the map of $str_{iy}$. \\ 5834\hspace{3mm}6.2 If $str_{iy}$ is not in the map or $y \ge r$ then goto step 7. \\ 5835\hspace{3mm}6.3 $a \leftarrow a \cdot r$ \\ 5836\hspace{3mm}6.4 $a \leftarrow a + y$ \\ 58377. If $a \ne 0$ then $a.sign \leftarrow sign$ \\ 58388. Return(\textit{MP\_OKAY}). \\ 5839\hline 5840\end{tabular} 5841\end{center} 5842\end{small} 5843\caption{Algorithm mp\_read\_radix} 5844\end{figure} 5845\textbf{Algorithm mp\_read\_radix.} 5846This algorithm will read an ASCII string and produce the radix-$\beta$ mp\_int representation of the same integer. A minus symbol ``-'' may precede the 5847string to indicate the value is negative, otherwise it is assumed to be positive. The algorithm will read up to $sn$ characters from the input 5848and will stop when it reads a character it cannot map the algorithm stops reading characters from the string. This allows numbers to be embedded 5849as part of larger input without any significant problem. 5850 5851\vspace{+3mm}\begin{small} 5852\hspace{-5.1mm}{\bf File}: bn\_mp\_read\_radix.c 5853\vspace{-3mm} 5854\begin{alltt} 5855\end{alltt} 5856\end{small} 5857 5858\subsection{Generating Radix-$n$ Output} 5859Generating radix-$n$ output is fairly trivial with a division and remainder algorithm. 5860 5861\newpage\begin{figure}[!here] 5862\begin{small} 5863\begin{center} 5864\begin{tabular}{l} 5865\hline Algorithm \textbf{mp\_toradix}. \\ 5866\textbf{Input}. A mp\_int $a$ and an integer $r$\\ 5867\textbf{Output}. The radix-$r$ representation of $a$ \\ 5868\hline \\ 58691. If $r < 2$ or $r > 64$ return(\textit{MP\_VAL}). \\ 58702. If $a = 0$ then $str = $ ``$0$'' and return(\textit{MP\_OKAY}). \\ 58713. $t \leftarrow a$ \\ 58724. $str \leftarrow$ ``'' \\ 58735. if $t.sign = MP\_NEG$ then \\ 5874\hspace{3mm}5.1 $str \leftarrow str + $ ``-'' \\ 5875\hspace{3mm}5.2 $t.sign = MP\_ZPOS$ \\ 58766. While ($t \ne 0$) do \\ 5877\hspace{3mm}6.1 $d \leftarrow t \mbox{ (mod }r\mbox{)}$ \\ 5878\hspace{3mm}6.2 $t \leftarrow \lfloor t / r \rfloor$ \\ 5879\hspace{3mm}6.3 Look up $d$ in the map and store the equivalent character in $y$. \\ 5880\hspace{3mm}6.4 $str \leftarrow str + y$ \\ 58817. If $str_0 = $``$-$'' then \\ 5882\hspace{3mm}7.1 Reverse the digits $str_1, str_2, \ldots str_n$. \\ 58838. Otherwise \\ 5884\hspace{3mm}8.1 Reverse the digits $str_0, str_1, \ldots str_n$. \\ 58859. Return(\textit{MP\_OKAY}).\\ 5886\hline 5887\end{tabular} 5888\end{center} 5889\end{small} 5890\caption{Algorithm mp\_toradix} 5891\end{figure} 5892\textbf{Algorithm mp\_toradix.} 5893This algorithm computes the radix-$r$ representation of an mp\_int $a$. The ``digits'' of the representation are extracted by reducing 5894successive powers of $\lfloor a / r^k \rfloor$ the input modulo $r$ until $r^k > a$. Note that instead of actually dividing by $r^k$ in 5895each iteration the quotient $\lfloor a / r \rfloor$ is saved for the next iteration. As a result a series of trivial $n \times 1$ divisions 5896are required instead of a series of $n \times k$ divisions. One design flaw of this approach is that the digits are produced in the reverse order 5897(see~\ref{fig:mpradix}). To remedy this flaw the digits must be swapped or simply ``reversed''. 5898 5899\begin{figure} 5900\begin{center} 5901\begin{tabular}{|c|c|c|} 5902\hline \textbf{Value of $a$} & \textbf{Value of $d$} & \textbf{Value of $str$} \\ 5903\hline $1234$ & -- & -- \\ 5904\hline $123$ & $4$ & ``4'' \\ 5905\hline $12$ & $3$ & ``43'' \\ 5906\hline $1$ & $2$ & ``432'' \\ 5907\hline $0$ & $1$ & ``4321'' \\ 5908\hline 5909\end{tabular} 5910\end{center} 5911\caption{Example of Algorithm mp\_toradix.} 5912\label{fig:mpradix} 5913\end{figure} 5914 5915\vspace{+3mm}\begin{small} 5916\hspace{-5.1mm}{\bf File}: bn\_mp\_toradix.c 5917\vspace{-3mm} 5918\begin{alltt} 5919\end{alltt} 5920\end{small} 5921 5922\chapter{Number Theoretic Algorithms} 5923This chapter discusses several fundamental number theoretic algorithms such as the greatest common divisor, least common multiple and Jacobi 5924symbol computation. These algorithms arise as essential components in several key cryptographic algorithms such as the RSA public key algorithm and 5925various Sieve based factoring algorithms. 5926 5927\section{Greatest Common Divisor} 5928The greatest common divisor of two integers $a$ and $b$, often denoted as $(a, b)$ is the largest integer $k$ that is a proper divisor of 5929both $a$ and $b$. That is, $k$ is the largest integer such that $0 \equiv a \mbox{ (mod }k\mbox{)}$ and $0 \equiv b \mbox{ (mod }k\mbox{)}$ occur 5930simultaneously. 5931 5932The most common approach (cite) is to reduce one input modulo another. That is if $a$ and $b$ are divisible by some integer $k$ and if $qa + r = b$ then 5933$r$ is also divisible by $k$. The reduction pattern follows $\left < a , b \right > \rightarrow \left < b, a \mbox{ mod } b \right >$. 5934 5935\newpage\begin{figure}[!here] 5936\begin{small} 5937\begin{center} 5938\begin{tabular}{l} 5939\hline Algorithm \textbf{Greatest Common Divisor (I)}. \\ 5940\textbf{Input}. Two positive integers $a$ and $b$ greater than zero. \\ 5941\textbf{Output}. The greatest common divisor $(a, b)$. \\ 5942\hline \\ 59431. While ($b > 0$) do \\ 5944\hspace{3mm}1.1 $r \leftarrow a \mbox{ (mod }b\mbox{)}$ \\ 5945\hspace{3mm}1.2 $a \leftarrow b$ \\ 5946\hspace{3mm}1.3 $b \leftarrow r$ \\ 59472. Return($a$). \\ 5948\hline 5949\end{tabular} 5950\end{center} 5951\end{small} 5952\caption{Algorithm Greatest Common Divisor (I)} 5953\label{fig:gcd1} 5954\end{figure} 5955 5956This algorithm will quickly converge on the greatest common divisor since the residue $r$ tends diminish rapidly. However, divisions are 5957relatively expensive operations to perform and should ideally be avoided. There is another approach based on a similar relationship of 5958greatest common divisors. The faster approach is based on the observation that if $k$ divides both $a$ and $b$ it will also divide $a - b$. 5959In particular, we would like $a - b$ to decrease in magnitude which implies that $b \ge a$. 5960 5961\begin{figure}[!here] 5962\begin{small} 5963\begin{center} 5964\begin{tabular}{l} 5965\hline Algorithm \textbf{Greatest Common Divisor (II)}. \\ 5966\textbf{Input}. Two positive integers $a$ and $b$ greater than zero. \\ 5967\textbf{Output}. The greatest common divisor $(a, b)$. \\ 5968\hline \\ 59691. While ($b > 0$) do \\ 5970\hspace{3mm}1.1 Swap $a$ and $b$ such that $a$ is the smallest of the two. \\ 5971\hspace{3mm}1.2 $b \leftarrow b - a$ \\ 59722. Return($a$). \\ 5973\hline 5974\end{tabular} 5975\end{center} 5976\end{small} 5977\caption{Algorithm Greatest Common Divisor (II)} 5978\label{fig:gcd2} 5979\end{figure} 5980 5981\textbf{Proof} \textit{Algorithm~\ref{fig:gcd2} will return the greatest common divisor of $a$ and $b$.} 5982The algorithm in figure~\ref{fig:gcd2} will eventually terminate since $b \ge a$ the subtraction in step 1.2 will be a value less than $b$. In other 5983words in every iteration that tuple $\left < a, b \right >$ decrease in magnitude until eventually $a = b$. Since both $a$ and $b$ are always 5984divisible by the greatest common divisor (\textit{until the last iteration}) and in the last iteration of the algorithm $b = 0$, therefore, in the 5985second to last iteration of the algorithm $b = a$ and clearly $(a, a) = a$ which concludes the proof. \textbf{QED}. 5986 5987As a matter of practicality algorithm \ref{fig:gcd1} decreases far too slowly to be useful. Specially if $b$ is much larger than $a$ such that 5988$b - a$ is still very much larger than $a$. A simple addition to the algorithm is to divide $b - a$ by a power of some integer $p$ which does 5989not divide the greatest common divisor but will divide $b - a$. In this case ${b - a} \over p$ is also an integer and still divisible by 5990the greatest common divisor. 5991 5992However, instead of factoring $b - a$ to find a suitable value of $p$ the powers of $p$ can be removed from $a$ and $b$ that are in common first. 5993Then inside the loop whenever $b - a$ is divisible by some power of $p$ it can be safely removed. 5994 5995\begin{figure}[!here] 5996\begin{small} 5997\begin{center} 5998\begin{tabular}{l} 5999\hline Algorithm \textbf{Greatest Common Divisor (III)}. \\ 6000\textbf{Input}. Two positive integers $a$ and $b$ greater than zero. \\ 6001\textbf{Output}. The greatest common divisor $(a, b)$. \\ 6002\hline \\ 60031. $k \leftarrow 0$ \\ 60042. While $a$ and $b$ are both divisible by $p$ do \\ 6005\hspace{3mm}2.1 $a \leftarrow \lfloor a / p \rfloor$ \\ 6006\hspace{3mm}2.2 $b \leftarrow \lfloor b / p \rfloor$ \\ 6007\hspace{3mm}2.3 $k \leftarrow k + 1$ \\ 60083. While $a$ is divisible by $p$ do \\ 6009\hspace{3mm}3.1 $a \leftarrow \lfloor a / p \rfloor$ \\ 60104. While $b$ is divisible by $p$ do \\ 6011\hspace{3mm}4.1 $b \leftarrow \lfloor b / p \rfloor$ \\ 60125. While ($b > 0$) do \\ 6013\hspace{3mm}5.1 Swap $a$ and $b$ such that $a$ is the smallest of the two. \\ 6014\hspace{3mm}5.2 $b \leftarrow b - a$ \\ 6015\hspace{3mm}5.3 While $b$ is divisible by $p$ do \\ 6016\hspace{6mm}5.3.1 $b \leftarrow \lfloor b / p \rfloor$ \\ 60176. Return($a \cdot p^k$). \\ 6018\hline 6019\end{tabular} 6020\end{center} 6021\end{small} 6022\caption{Algorithm Greatest Common Divisor (III)} 6023\label{fig:gcd3} 6024\end{figure} 6025 6026This algorithm is based on the first except it removes powers of $p$ first and inside the main loop to ensure the tuple $\left < a, b \right >$ 6027decreases more rapidly. The first loop on step two removes powers of $p$ that are in common. A count, $k$, is kept which will present a common 6028divisor of $p^k$. After step two the remaining common divisor of $a$ and $b$ cannot be divisible by $p$. This means that $p$ can be safely 6029divided out of the difference $b - a$ so long as the division leaves no remainder. 6030 6031In particular the value of $p$ should be chosen such that the division on step 5.3.1 occur often. It also helps that division by $p$ be easy 6032to compute. The ideal choice of $p$ is two since division by two amounts to a right logical shift. Another important observation is that by 6033step five both $a$ and $b$ are odd. Therefore, the diffrence $b - a$ must be even which means that each iteration removes one bit from the 6034largest of the pair. 6035 6036\subsection{Complete Greatest Common Divisor} 6037The algorithms presented so far cannot handle inputs which are zero or negative. The following algorithm can handle all input cases properly 6038and will produce the greatest common divisor. 6039 6040\newpage\begin{figure}[!here] 6041\begin{small} 6042\begin{center} 6043\begin{tabular}{l} 6044\hline Algorithm \textbf{mp\_gcd}. \\ 6045\textbf{Input}. mp\_int $a$ and $b$ \\ 6046\textbf{Output}. The greatest common divisor $c = (a, b)$. \\ 6047\hline \\ 60481. If $a = 0$ then \\ 6049\hspace{3mm}1.1 $c \leftarrow \vert b \vert $ \\ 6050\hspace{3mm}1.2 Return(\textit{MP\_OKAY}). \\ 60512. If $b = 0$ then \\ 6052\hspace{3mm}2.1 $c \leftarrow \vert a \vert $ \\ 6053\hspace{3mm}2.2 Return(\textit{MP\_OKAY}). \\ 60543. $u \leftarrow \vert a \vert, v \leftarrow \vert b \vert$ \\ 60554. $k \leftarrow 0$ \\ 60565. While $u.used > 0$ and $v.used > 0$ and $u_0 \equiv v_0 \equiv 0 \mbox{ (mod }2\mbox{)}$ \\ 6057\hspace{3mm}5.1 $k \leftarrow k + 1$ \\ 6058\hspace{3mm}5.2 $u \leftarrow \lfloor u / 2 \rfloor$ \\ 6059\hspace{3mm}5.3 $v \leftarrow \lfloor v / 2 \rfloor$ \\ 60606. While $u.used > 0$ and $u_0 \equiv 0 \mbox{ (mod }2\mbox{)}$ \\ 6061\hspace{3mm}6.1 $u \leftarrow \lfloor u / 2 \rfloor$ \\ 60627. While $v.used > 0$ and $v_0 \equiv 0 \mbox{ (mod }2\mbox{)}$ \\ 6063\hspace{3mm}7.1 $v \leftarrow \lfloor v / 2 \rfloor$ \\ 60648. While $v.used > 0$ \\ 6065\hspace{3mm}8.1 If $\vert u \vert > \vert v \vert$ then \\ 6066\hspace{6mm}8.1.1 Swap $u$ and $v$. \\ 6067\hspace{3mm}8.2 $v \leftarrow \vert v \vert - \vert u \vert$ \\ 6068\hspace{3mm}8.3 While $v.used > 0$ and $v_0 \equiv 0 \mbox{ (mod }2\mbox{)}$ \\ 6069\hspace{6mm}8.3.1 $v \leftarrow \lfloor v / 2 \rfloor$ \\ 60709. $c \leftarrow u \cdot 2^k$ \\ 607110. Return(\textit{MP\_OKAY}). \\ 6072\hline 6073\end{tabular} 6074\end{center} 6075\end{small} 6076\caption{Algorithm mp\_gcd} 6077\end{figure} 6078\textbf{Algorithm mp\_gcd.} 6079This algorithm will produce the greatest common divisor of two mp\_ints $a$ and $b$. The algorithm was originally based on Algorithm B of 6080Knuth \cite[pp. 338]{TAOCPV2} but has been modified to be simpler to explain. In theory it achieves the same asymptotic working time as 6081Algorithm B and in practice this appears to be true. 6082 6083The first two steps handle the cases where either one of or both inputs are zero. If either input is zero the greatest common divisor is the 6084largest input or zero if they are both zero. If the inputs are not trivial than $u$ and $v$ are assigned the absolute values of 6085$a$ and $b$ respectively and the algorithm will proceed to reduce the pair. 6086 6087Step five will divide out any common factors of two and keep track of the count in the variable $k$. After this step, two is no longer a 6088factor of the remaining greatest common divisor between $u$ and $v$ and can be safely evenly divided out of either whenever they are even. Step 6089six and seven ensure that the $u$ and $v$ respectively have no more factors of two. At most only one of the while--loops will iterate since 6090they cannot both be even. 6091 6092By step eight both of $u$ and $v$ are odd which is required for the inner logic. First the pair are swapped such that $v$ is equal to 6093or greater than $u$. This ensures that the subtraction on step 8.2 will always produce a positive and even result. Step 8.3 removes any 6094factors of two from the difference $u$ to ensure that in the next iteration of the loop both are once again odd. 6095 6096After $v = 0$ occurs the variable $u$ has the greatest common divisor of the pair $\left < u, v \right >$ just after step six. The result 6097must be adjusted by multiplying by the common factors of two ($2^k$) removed earlier. 6098 6099\vspace{+3mm}\begin{small} 6100\hspace{-5.1mm}{\bf File}: bn\_mp\_gcd.c 6101\vspace{-3mm} 6102\begin{alltt} 6103\end{alltt} 6104\end{small} 6105 6106This function makes use of the macros mp\_iszero and mp\_iseven. The former evaluates to $1$ if the input mp\_int is equivalent to the 6107integer zero otherwise it evaluates to $0$. The latter evaluates to $1$ if the input mp\_int represents a non-zero even integer otherwise 6108it evaluates to $0$. Note that just because mp\_iseven may evaluate to $0$ does not mean the input is odd, it could also be zero. The three 6109trivial cases of inputs are handled on lines 24 through 30. After those lines the inputs are assumed to be non-zero. 6110 6111Lines 32 and 37 make local copies $u$ and $v$ of the inputs $a$ and $b$ respectively. At this point the common factors of two 6112must be divided out of the two inputs. The block starting at line 44 removes common factors of two by first counting the number of trailing 6113zero bits in both. The local integer $k$ is used to keep track of how many factors of $2$ are pulled out of both values. It is assumed that 6114the number of factors will not exceed the maximum value of a C ``int'' data type\footnote{Strictly speaking no array in C may have more than 6115entries than are accessible by an ``int'' so this is not a limitation.}. 6116 6117At this point there are no more common factors of two in the two values. The divisions by a power of two on lines 62 and 68 remove 6118any independent factors of two such that both $u$ and $v$ are guaranteed to be an odd integer before hitting the main body of the algorithm. The while loop 6119on line 73 performs the reduction of the pair until $v$ is equal to zero. The unsigned comparison and subtraction algorithms are used in 6120place of the full signed routines since both values are guaranteed to be positive and the result of the subtraction is guaranteed to be non-negative. 6121 6122\section{Least Common Multiple} 6123The least common multiple of a pair of integers is their product divided by their greatest common divisor. For two integers $a$ and $b$ the 6124least common multiple is normally denoted as $[ a, b ]$ and numerically equivalent to ${ab} \over {(a, b)}$. For example, if $a = 2 \cdot 2 \cdot 3 = 12$ 6125and $b = 2 \cdot 3 \cdot 3 \cdot 7 = 126$ the least common multiple is ${126 \over {(12, 126)}} = {126 \over 6} = 21$. 6126 6127The least common multiple arises often in coding theory as well as number theory. If two functions have periods of $a$ and $b$ respectively they will 6128collide, that is be in synchronous states, after only $[ a, b ]$ iterations. This is why, for example, random number generators based on 6129Linear Feedback Shift Registers (LFSR) tend to use registers with periods which are co-prime (\textit{e.g. the greatest common divisor is one.}). 6130Similarly in number theory if a composite $n$ has two prime factors $p$ and $q$ then maximal order of any unit of $\Z/n\Z$ will be $[ p - 1, q - 1] $. 6131 6132\begin{figure}[!here] 6133\begin{small} 6134\begin{center} 6135\begin{tabular}{l} 6136\hline Algorithm \textbf{mp\_lcm}. \\ 6137\textbf{Input}. mp\_int $a$ and $b$ \\ 6138\textbf{Output}. The least common multiple $c = [a, b]$. \\ 6139\hline \\ 61401. $c \leftarrow (a, b)$ \\ 61412. $t \leftarrow a \cdot b$ \\ 61423. $c \leftarrow \lfloor t / c \rfloor$ \\ 61434. Return(\textit{MP\_OKAY}). \\ 6144\hline 6145\end{tabular} 6146\end{center} 6147\end{small} 6148\caption{Algorithm mp\_lcm} 6149\end{figure} 6150\textbf{Algorithm mp\_lcm.} 6151This algorithm computes the least common multiple of two mp\_int inputs $a$ and $b$. It computes the least common multiple directly by 6152dividing the product of the two inputs by their greatest common divisor. 6153 6154\vspace{+3mm}\begin{small} 6155\hspace{-5.1mm}{\bf File}: bn\_mp\_lcm.c 6156\vspace{-3mm} 6157\begin{alltt} 6158\end{alltt} 6159\end{small} 6160 6161\section{Jacobi Symbol Computation} 6162To explain the Jacobi Symbol we shall first discuss the Legendre function\footnote{Arrg. What is the name of this?} off which the Jacobi symbol is 6163defined. The Legendre function computes whether or not an integer $a$ is a quadratic residue modulo an odd prime $p$. Numerically it is 6164equivalent to equation \ref{eqn:legendre}. 6165 6166\textit{-- Tom, don't be an ass, cite your source here...!} 6167 6168\begin{equation} 6169a^{(p-1)/2} \equiv \begin{array}{rl} 6170 -1 & \mbox{if }a\mbox{ is a quadratic non-residue.} \\ 6171 0 & \mbox{if }a\mbox{ divides }p\mbox{.} \\ 6172 1 & \mbox{if }a\mbox{ is a quadratic residue}. 6173 \end{array} \mbox{ (mod }p\mbox{)} 6174\label{eqn:legendre} 6175\end{equation} 6176 6177\textbf{Proof.} \textit{Equation \ref{eqn:legendre} correctly identifies the residue status of an integer $a$ modulo a prime $p$.} 6178An integer $a$ is a quadratic residue if the following equation has a solution. 6179 6180\begin{equation} 6181x^2 \equiv a \mbox{ (mod }p\mbox{)} 6182\label{eqn:root} 6183\end{equation} 6184 6185Consider the following equation. 6186 6187\begin{equation} 61880 \equiv x^{p-1} - 1 \equiv \left \lbrace \left (x^2 \right )^{(p-1)/2} - a^{(p-1)/2} \right \rbrace + \left ( a^{(p-1)/2} - 1 \right ) \mbox{ (mod }p\mbox{)} 6189\label{eqn:rooti} 6190\end{equation} 6191 6192Whether equation \ref{eqn:root} has a solution or not equation \ref{eqn:rooti} is always true. If $a^{(p-1)/2} - 1 \equiv 0 \mbox{ (mod }p\mbox{)}$ 6193then the quantity in the braces must be zero. By reduction, 6194 6195\begin{eqnarray} 6196\left (x^2 \right )^{(p-1)/2} - a^{(p-1)/2} \equiv 0 \nonumber \\ 6197\left (x^2 \right )^{(p-1)/2} \equiv a^{(p-1)/2} \nonumber \\ 6198x^2 \equiv a \mbox{ (mod }p\mbox{)} 6199\end{eqnarray} 6200 6201As a result there must be a solution to the quadratic equation and in turn $a$ must be a quadratic residue. If $a$ does not divide $p$ and $a$ 6202is not a quadratic residue then the only other value $a^{(p-1)/2}$ may be congruent to is $-1$ since 6203\begin{equation} 62040 \equiv a^{p - 1} - 1 \equiv (a^{(p-1)/2} + 1)(a^{(p-1)/2} - 1) \mbox{ (mod }p\mbox{)} 6205\end{equation} 6206One of the terms on the right hand side must be zero. \textbf{QED} 6207 6208\subsection{Jacobi Symbol} 6209The Jacobi symbol is a generalization of the Legendre function for any odd non prime moduli $p$ greater than 2. If $p = \prod_{i=0}^n p_i$ then 6210the Jacobi symbol $\left ( { a \over p } \right )$ is equal to the following equation. 6211 6212\begin{equation} 6213\left ( { a \over p } \right ) = \left ( { a \over p_0} \right ) \left ( { a \over p_1} \right ) \ldots \left ( { a \over p_n} \right ) 6214\end{equation} 6215 6216By inspection if $p$ is prime the Jacobi symbol is equivalent to the Legendre function. The following facts\footnote{See HAC \cite[pp. 72-74]{HAC} for 6217further details.} will be used to derive an efficient Jacobi symbol algorithm. Where $p$ is an odd integer greater than two and $a, b \in \Z$ the 6218following are true. 6219 6220\begin{enumerate} 6221\item $\left ( { a \over p} \right )$ equals $-1$, $0$ or $1$. 6222\item $\left ( { ab \over p} \right ) = \left ( { a \over p} \right )\left ( { b \over p} \right )$. 6223\item If $a \equiv b$ then $\left ( { a \over p} \right ) = \left ( { b \over p} \right )$. 6224\item $\left ( { 2 \over p} \right )$ equals $1$ if $p \equiv 1$ or $7 \mbox{ (mod }8\mbox{)}$. Otherwise, it equals $-1$. 6225\item $\left ( { a \over p} \right ) \equiv \left ( { p \over a} \right ) \cdot (-1)^{(p-1)(a-1)/4}$. More specifically 6226$\left ( { a \over p} \right ) = \left ( { p \over a} \right )$ if $p \equiv a \equiv 1 \mbox{ (mod }4\mbox{)}$. 6227\end{enumerate} 6228 6229Using these facts if $a = 2^k \cdot a'$ then 6230 6231\begin{eqnarray} 6232\left ( { a \over p } \right ) = \left ( {{2^k} \over p } \right ) \left ( {a' \over p} \right ) \nonumber \\ 6233 = \left ( {2 \over p } \right )^k \left ( {a' \over p} \right ) 6234\label{eqn:jacobi} 6235\end{eqnarray} 6236 6237By fact five, 6238 6239\begin{equation} 6240\left ( { a \over p } \right ) = \left ( { p \over a } \right ) \cdot (-1)^{(p-1)(a-1)/4} 6241\end{equation} 6242 6243Subsequently by fact three since $p \equiv (p \mbox{ mod }a) \mbox{ (mod }a\mbox{)}$ then 6244 6245\begin{equation} 6246\left ( { a \over p } \right ) = \left ( { {p \mbox{ mod } a} \over a } \right ) \cdot (-1)^{(p-1)(a-1)/4} 6247\end{equation} 6248 6249By putting both observations into equation \ref{eqn:jacobi} the following simplified equation is formed. 6250 6251\begin{equation} 6252\left ( { a \over p } \right ) = \left ( {2 \over p } \right )^k \left ( {{p\mbox{ mod }a'} \over a'} \right ) \cdot (-1)^{(p-1)(a'-1)/4} 6253\end{equation} 6254 6255The value of $\left ( {{p \mbox{ mod }a'} \over a'} \right )$ can be found by using the same equation recursively. The value of 6256$\left ( {2 \over p } \right )^k$ equals $1$ if $k$ is even otherwise it equals $\left ( {2 \over p } \right )$. Using this approach the 6257factors of $p$ do not have to be known. Furthermore, if $(a, p) = 1$ then the algorithm will terminate when the recursion requests the 6258Jacobi symbol computation of $\left ( {1 \over a'} \right )$ which is simply $1$. 6259 6260\newpage\begin{figure}[!here] 6261\begin{small} 6262\begin{center} 6263\begin{tabular}{l} 6264\hline Algorithm \textbf{mp\_jacobi}. \\ 6265\textbf{Input}. mp\_int $a$ and $p$, $a \ge 0$, $p \ge 3$, $p \equiv 1 \mbox{ (mod }2\mbox{)}$ \\ 6266\textbf{Output}. The Jacobi symbol $c = \left ( {a \over p } \right )$. \\ 6267\hline \\ 62681. If $a = 0$ then \\ 6269\hspace{3mm}1.1 $c \leftarrow 0$ \\ 6270\hspace{3mm}1.2 Return(\textit{MP\_OKAY}). \\ 62712. If $a = 1$ then \\ 6272\hspace{3mm}2.1 $c \leftarrow 1$ \\ 6273\hspace{3mm}2.2 Return(\textit{MP\_OKAY}). \\ 62743. $a' \leftarrow a$ \\ 62754. $k \leftarrow 0$ \\ 62765. While $a'.used > 0$ and $a'_0 \equiv 0 \mbox{ (mod }2\mbox{)}$ \\ 6277\hspace{3mm}5.1 $k \leftarrow k + 1$ \\ 6278\hspace{3mm}5.2 $a' \leftarrow \lfloor a' / 2 \rfloor$ \\ 62796. If $k \equiv 0 \mbox{ (mod }2\mbox{)}$ then \\ 6280\hspace{3mm}6.1 $s \leftarrow 1$ \\ 62817. else \\ 6282\hspace{3mm}7.1 $r \leftarrow p_0 \mbox{ (mod }8\mbox{)}$ \\ 6283\hspace{3mm}7.2 If $r = 1$ or $r = 7$ then \\ 6284\hspace{6mm}7.2.1 $s \leftarrow 1$ \\ 6285\hspace{3mm}7.3 else \\ 6286\hspace{6mm}7.3.1 $s \leftarrow -1$ \\ 62878. If $p_0 \equiv a'_0 \equiv 3 \mbox{ (mod }4\mbox{)}$ then \\ 6288\hspace{3mm}8.1 $s \leftarrow -s$ \\ 62899. If $a' \ne 1$ then \\ 6290\hspace{3mm}9.1 $p' \leftarrow p \mbox{ (mod }a'\mbox{)}$ \\ 6291\hspace{3mm}9.2 $s \leftarrow s \cdot \mbox{mp\_jacobi}(p', a')$ \\ 629210. $c \leftarrow s$ \\ 629311. Return(\textit{MP\_OKAY}). \\ 6294\hline 6295\end{tabular} 6296\end{center} 6297\end{small} 6298\caption{Algorithm mp\_jacobi} 6299\end{figure} 6300\textbf{Algorithm mp\_jacobi.} 6301This algorithm computes the Jacobi symbol for an arbitrary positive integer $a$ with respect to an odd integer $p$ greater than three. The algorithm 6302is based on algorithm 2.149 of HAC \cite[pp. 73]{HAC}. 6303 6304Step numbers one and two handle the trivial cases of $a = 0$ and $a = 1$ respectively. Step five determines the number of two factors in the 6305input $a$. If $k$ is even than the term $\left ( { 2 \over p } \right )^k$ must always evaluate to one. If $k$ is odd than the term evaluates to one 6306if $p_0$ is congruent to one or seven modulo eight, otherwise it evaluates to $-1$. After the the $\left ( { 2 \over p } \right )^k$ term is handled 6307the $(-1)^{(p-1)(a'-1)/4}$ is computed and multiplied against the current product $s$. The latter term evaluates to one if both $p$ and $a'$ 6308are congruent to one modulo four, otherwise it evaluates to negative one. 6309 6310By step nine if $a'$ does not equal one a recursion is required. Step 9.1 computes $p' \equiv p \mbox{ (mod }a'\mbox{)}$ and will recurse to compute 6311$\left ( {p' \over a'} \right )$ which is multiplied against the current Jacobi product. 6312 6313\vspace{+3mm}\begin{small} 6314\hspace{-5.1mm}{\bf File}: bn\_mp\_jacobi.c 6315\vspace{-3mm} 6316\begin{alltt} 6317\end{alltt} 6318\end{small} 6319 6320As a matter of practicality the variable $a'$ as per the pseudo-code is reprensented by the variable $a1$ since the $'$ symbol is not valid for a C 6321variable name character. 6322 6323The two simple cases of $a = 0$ and $a = 1$ are handled at the very beginning to simplify the algorithm. If the input is non-trivial the algorithm 6324has to proceed compute the Jacobi. The variable $s$ is used to hold the current Jacobi product. Note that $s$ is merely a C ``int'' data type since 6325the values it may obtain are merely $-1$, $0$ and $1$. 6326 6327After a local copy of $a$ is made all of the factors of two are divided out and the total stored in $k$. Technically only the least significant 6328bit of $k$ is required, however, it makes the algorithm simpler to follow to perform an addition. In practice an exclusive-or and addition have the same 6329processor requirements and neither is faster than the other. 6330 6331Line 58 through 71 determines the value of $\left ( { 2 \over p } \right )^k$. If the least significant bit of $k$ is zero than 6332$k$ is even and the value is one. Otherwise, the value of $s$ depends on which residue class $p$ belongs to modulo eight. The value of 6333$(-1)^{(p-1)(a'-1)/4}$ is compute and multiplied against $s$ on lines 71 through 74. 6334 6335Finally, if $a1$ does not equal one the algorithm must recurse and compute $\left ( {p' \over a'} \right )$. 6336 6337\textit{-- Comment about default $s$ and such...} 6338 6339\section{Modular Inverse} 6340\label{sec:modinv} 6341The modular inverse of a number actually refers to the modular multiplicative inverse. Essentially for any integer $a$ such that $(a, p) = 1$ there 6342exist another integer $b$ such that $ab \equiv 1 \mbox{ (mod }p\mbox{)}$. The integer $b$ is called the multiplicative inverse of $a$ which is 6343denoted as $b = a^{-1}$. Technically speaking modular inversion is a well defined operation for any finite ring or field not just for rings and 6344fields of integers. However, the former will be the matter of discussion. 6345 6346The simplest approach is to compute the algebraic inverse of the input. That is to compute $b \equiv a^{\Phi(p) - 1}$. If $\Phi(p)$ is the 6347order of the multiplicative subgroup modulo $p$ then $b$ must be the multiplicative inverse of $a$. The proof of which is trivial. 6348 6349\begin{equation} 6350ab \equiv a \left (a^{\Phi(p) - 1} \right ) \equiv a^{\Phi(p)} \equiv a^0 \equiv 1 \mbox{ (mod }p\mbox{)} 6351\end{equation} 6352 6353However, as simple as this approach may be it has two serious flaws. It requires that the value of $\Phi(p)$ be known which if $p$ is composite 6354requires all of the prime factors. This approach also is very slow as the size of $p$ grows. 6355 6356A simpler approach is based on the observation that solving for the multiplicative inverse is equivalent to solving the linear 6357Diophantine\footnote{See LeVeque \cite[pp. 40-43]{LeVeque} for more information.} equation. 6358 6359\begin{equation} 6360ab + pq = 1 6361\end{equation} 6362 6363Where $a$, $b$, $p$ and $q$ are all integers. If such a pair of integers $ \left < b, q \right >$ exist than $b$ is the multiplicative inverse of 6364$a$ modulo $p$. The extended Euclidean algorithm (Knuth \cite[pp. 342]{TAOCPV2}) can be used to solve such equations provided $(a, p) = 1$. 6365However, instead of using that algorithm directly a variant known as the binary Extended Euclidean algorithm will be used in its place. The 6366binary approach is very similar to the binary greatest common divisor algorithm except it will produce a full solution to the Diophantine 6367equation. 6368 6369\subsection{General Case} 6370\newpage\begin{figure}[!here] 6371\begin{small} 6372\begin{center} 6373\begin{tabular}{l} 6374\hline Algorithm \textbf{mp\_invmod}. \\ 6375\textbf{Input}. mp\_int $a$ and $b$, $(a, b) = 1$, $p \ge 2$, $0 < a < p$. \\ 6376\textbf{Output}. The modular inverse $c \equiv a^{-1} \mbox{ (mod }b\mbox{)}$. \\ 6377\hline \\ 63781. If $b \le 0$ then return(\textit{MP\_VAL}). \\ 63792. If $b_0 \equiv 1 \mbox{ (mod }2\mbox{)}$ then use algorithm fast\_mp\_invmod. \\ 63803. $x \leftarrow \vert a \vert, y \leftarrow b$ \\ 63814. If $x_0 \equiv y_0 \equiv 0 \mbox{ (mod }2\mbox{)}$ then return(\textit{MP\_VAL}). \\ 63825. $B \leftarrow 0, C \leftarrow 0, A \leftarrow 1, D \leftarrow 1$ \\ 63836. While $u.used > 0$ and $u_0 \equiv 0 \mbox{ (mod }2\mbox{)}$ \\ 6384\hspace{3mm}6.1 $u \leftarrow \lfloor u / 2 \rfloor$ \\ 6385\hspace{3mm}6.2 If ($A.used > 0$ and $A_0 \equiv 1 \mbox{ (mod }2\mbox{)}$) or ($B.used > 0$ and $B_0 \equiv 1 \mbox{ (mod }2\mbox{)}$) then \\ 6386\hspace{6mm}6.2.1 $A \leftarrow A + y$ \\ 6387\hspace{6mm}6.2.2 $B \leftarrow B - x$ \\ 6388\hspace{3mm}6.3 $A \leftarrow \lfloor A / 2 \rfloor$ \\ 6389\hspace{3mm}6.4 $B \leftarrow \lfloor B / 2 \rfloor$ \\ 63907. While $v.used > 0$ and $v_0 \equiv 0 \mbox{ (mod }2\mbox{)}$ \\ 6391\hspace{3mm}7.1 $v \leftarrow \lfloor v / 2 \rfloor$ \\ 6392\hspace{3mm}7.2 If ($C.used > 0$ and $C_0 \equiv 1 \mbox{ (mod }2\mbox{)}$) or ($D.used > 0$ and $D_0 \equiv 1 \mbox{ (mod }2\mbox{)}$) then \\ 6393\hspace{6mm}7.2.1 $C \leftarrow C + y$ \\ 6394\hspace{6mm}7.2.2 $D \leftarrow D - x$ \\ 6395\hspace{3mm}7.3 $C \leftarrow \lfloor C / 2 \rfloor$ \\ 6396\hspace{3mm}7.4 $D \leftarrow \lfloor D / 2 \rfloor$ \\ 63978. If $u \ge v$ then \\ 6398\hspace{3mm}8.1 $u \leftarrow u - v$ \\ 6399\hspace{3mm}8.2 $A \leftarrow A - C$ \\ 6400\hspace{3mm}8.3 $B \leftarrow B - D$ \\ 64019. else \\ 6402\hspace{3mm}9.1 $v \leftarrow v - u$ \\ 6403\hspace{3mm}9.2 $C \leftarrow C - A$ \\ 6404\hspace{3mm}9.3 $D \leftarrow D - B$ \\ 640510. If $u \ne 0$ goto step 6. \\ 640611. If $v \ne 1$ return(\textit{MP\_VAL}). \\ 640712. While $C \le 0$ do \\ 6408\hspace{3mm}12.1 $C \leftarrow C + b$ \\ 640913. While $C \ge b$ do \\ 6410\hspace{3mm}13.1 $C \leftarrow C - b$ \\ 641114. $c \leftarrow C$ \\ 641215. Return(\textit{MP\_OKAY}). \\ 6413\hline 6414\end{tabular} 6415\end{center} 6416\end{small} 6417\end{figure} 6418\textbf{Algorithm mp\_invmod.} 6419This algorithm computes the modular multiplicative inverse of an integer $a$ modulo an integer $b$. This algorithm is a variation of the 6420extended binary Euclidean algorithm from HAC \cite[pp. 608]{HAC}. It has been modified to only compute the modular inverse and not a complete 6421Diophantine solution. 6422 6423If $b \le 0$ than the modulus is invalid and MP\_VAL is returned. Similarly if both $a$ and $b$ are even then there cannot be a multiplicative 6424inverse for $a$ and the error is reported. 6425 6426The astute reader will observe that steps seven through nine are very similar to the binary greatest common divisor algorithm mp\_gcd. In this case 6427the other variables to the Diophantine equation are solved. The algorithm terminates when $u = 0$ in which case the solution is 6428 6429\begin{equation} 6430Ca + Db = v 6431\end{equation} 6432 6433If $v$, the greatest common divisor of $a$ and $b$ is not equal to one then the algorithm will report an error as no inverse exists. Otherwise, $C$ 6434is the modular inverse of $a$. The actual value of $C$ is congruent to, but not necessarily equal to, the ideal modular inverse which should lie 6435within $1 \le a^{-1} < b$. Step numbers twelve and thirteen adjust the inverse until it is in range. If the original input $a$ is within $0 < a < p$ 6436then only a couple of additions or subtractions will be required to adjust the inverse. 6437 6438\vspace{+3mm}\begin{small} 6439\hspace{-5.1mm}{\bf File}: bn\_mp\_invmod.c 6440\vspace{-3mm} 6441\begin{alltt} 6442\end{alltt} 6443\end{small} 6444 6445\subsubsection{Odd Moduli} 6446 6447When the modulus $b$ is odd the variables $A$ and $C$ are fixed and are not required to compute the inverse. In particular by attempting to solve 6448the Diophantine $Cb + Da = 1$ only $B$ and $D$ are required to find the inverse of $a$. 6449 6450The algorithm fast\_mp\_invmod is a direct adaptation of algorithm mp\_invmod with all all steps involving either $A$ or $C$ removed. This 6451optimization will halve the time required to compute the modular inverse. 6452 6453\section{Primality Tests} 6454 6455A non-zero integer $a$ is said to be prime if it is not divisible by any other integer excluding one and itself. For example, $a = 7$ is prime 6456since the integers $2 \ldots 6$ do not evenly divide $a$. By contrast, $a = 6$ is not prime since $a = 6 = 2 \cdot 3$. 6457 6458Prime numbers arise in cryptography considerably as they allow finite fields to be formed. The ability to determine whether an integer is prime or 6459not quickly has been a viable subject in cryptography and number theory for considerable time. The algorithms that will be presented are all 6460probablistic algorithms in that when they report an integer is composite it must be composite. However, when the algorithms report an integer is 6461prime the algorithm may be incorrect. 6462 6463As will be discussed it is possible to limit the probability of error so well that for practical purposes the probablity of error might as 6464well be zero. For the purposes of these discussions let $n$ represent the candidate integer of which the primality is in question. 6465 6466\subsection{Trial Division} 6467 6468Trial division means to attempt to evenly divide a candidate integer by small prime integers. If the candidate can be evenly divided it obviously 6469cannot be prime. By dividing by all primes $1 < p \le \sqrt{n}$ this test can actually prove whether an integer is prime. However, such a test 6470would require a prohibitive amount of time as $n$ grows. 6471 6472Instead of dividing by every prime, a smaller, more mangeable set of primes may be used instead. By performing trial division with only a subset 6473of the primes less than $\sqrt{n} + 1$ the algorithm cannot prove if a candidate is prime. However, often it can prove a candidate is not prime. 6474 6475The benefit of this test is that trial division by small values is fairly efficient. Specially compared to the other algorithms that will be 6476discussed shortly. The probability that this approach correctly identifies a composite candidate when tested with all primes upto $q$ is given by 6477$1 - {1.12 \over ln(q)}$. The graph (\ref{pic:primality}, will be added later) demonstrates the probability of success for the range 6478$3 \le q \le 100$. 6479 6480At approximately $q = 30$ the gain of performing further tests diminishes fairly quickly. At $q = 90$ further testing is generally not going to 6481be of any practical use. In the case of LibTomMath the default limit $q = 256$ was chosen since it is not too high and will eliminate 6482approximately $80\%$ of all candidate integers. The constant \textbf{PRIME\_SIZE} is equal to the number of primes in the test base. The 6483array \_\_prime\_tab is an array of the first \textbf{PRIME\_SIZE} prime numbers. 6484 6485\begin{figure}[!here] 6486\begin{small} 6487\begin{center} 6488\begin{tabular}{l} 6489\hline Algorithm \textbf{mp\_prime\_is\_divisible}. \\ 6490\textbf{Input}. mp\_int $a$ \\ 6491\textbf{Output}. $c = 1$ if $n$ is divisible by a small prime, otherwise $c = 0$. \\ 6492\hline \\ 64931. for $ix$ from $0$ to $PRIME\_SIZE$ do \\ 6494\hspace{3mm}1.1 $d \leftarrow n \mbox{ (mod }\_\_prime\_tab_{ix}\mbox{)}$ \\ 6495\hspace{3mm}1.2 If $d = 0$ then \\ 6496\hspace{6mm}1.2.1 $c \leftarrow 1$ \\ 6497\hspace{6mm}1.2.2 Return(\textit{MP\_OKAY}). \\ 64982. $c \leftarrow 0$ \\ 64993. Return(\textit{MP\_OKAY}). \\ 6500\hline 6501\end{tabular} 6502\end{center} 6503\end{small} 6504\caption{Algorithm mp\_prime\_is\_divisible} 6505\end{figure} 6506\textbf{Algorithm mp\_prime\_is\_divisible.} 6507This algorithm attempts to determine if a candidate integer $n$ is composite by performing trial divisions. 6508 6509\vspace{+3mm}\begin{small} 6510\hspace{-5.1mm}{\bf File}: bn\_mp\_prime\_is\_divisible.c 6511\vspace{-3mm} 6512\begin{alltt} 6513\end{alltt} 6514\end{small} 6515 6516The algorithm defaults to a return of $0$ in case an error occurs. The values in the prime table are all specified to be in the range of a 6517mp\_digit. The table \_\_prime\_tab is defined in the following file. 6518 6519\vspace{+3mm}\begin{small} 6520\hspace{-5.1mm}{\bf File}: bn\_prime\_tab.c 6521\vspace{-3mm} 6522\begin{alltt} 6523\end{alltt} 6524\end{small} 6525 6526Note that there are two possible tables. When an mp\_digit is 7-bits long only the primes upto $127$ may be included, otherwise the primes 6527upto $1619$ are used. Note that the value of \textbf{PRIME\_SIZE} is a constant dependent on the size of a mp\_digit. 6528 6529\subsection{The Fermat Test} 6530The Fermat test is probably one the oldest tests to have a non-trivial probability of success. It is based on the fact that if $n$ is in 6531fact prime then $a^{n} \equiv a \mbox{ (mod }n\mbox{)}$ for all $0 < a < n$. The reason being that if $n$ is prime than the order of 6532the multiplicative sub group is $n - 1$. Any base $a$ must have an order which divides $n - 1$ and as such $a^n$ is equivalent to 6533$a^1 = a$. 6534 6535If $n$ is composite then any given base $a$ does not have to have a period which divides $n - 1$. In which case 6536it is possible that $a^n \nequiv a \mbox{ (mod }n\mbox{)}$. However, this test is not absolute as it is possible that the order 6537of a base will divide $n - 1$ which would then be reported as prime. Such a base yields what is known as a Fermat pseudo-prime. Several 6538integers known as Carmichael numbers will be a pseudo-prime to all valid bases. Fortunately such numbers are extremely rare as $n$ grows 6539in size. 6540 6541\begin{figure}[!here] 6542\begin{small} 6543\begin{center} 6544\begin{tabular}{l} 6545\hline Algorithm \textbf{mp\_prime\_fermat}. \\ 6546\textbf{Input}. mp\_int $a$ and $b$, $a \ge 2$, $0 < b < a$. \\ 6547\textbf{Output}. $c = 1$ if $b^a \equiv b \mbox{ (mod }a\mbox{)}$, otherwise $c = 0$. \\ 6548\hline \\ 65491. $t \leftarrow b^a \mbox{ (mod }a\mbox{)}$ \\ 65502. If $t = b$ then \\ 6551\hspace{3mm}2.1 $c = 1$ \\ 65523. else \\ 6553\hspace{3mm}3.1 $c = 0$ \\ 65544. Return(\textit{MP\_OKAY}). \\ 6555\hline 6556\end{tabular} 6557\end{center} 6558\end{small} 6559\caption{Algorithm mp\_prime\_fermat} 6560\end{figure} 6561\textbf{Algorithm mp\_prime\_fermat.} 6562This algorithm determines whether an mp\_int $a$ is a Fermat prime to the base $b$ or not. It uses a single modular exponentiation to 6563determine the result. 6564 6565\vspace{+3mm}\begin{small} 6566\hspace{-5.1mm}{\bf File}: bn\_mp\_prime\_fermat.c 6567\vspace{-3mm} 6568\begin{alltt} 6569\end{alltt} 6570\end{small} 6571 6572\subsection{The Miller-Rabin Test} 6573The Miller-Rabin (citation) test is another primality test which has tighter error bounds than the Fermat test specifically with sequentially chosen 6574candidate integers. The algorithm is based on the observation that if $n - 1 = 2^kr$ and if $b^r \nequiv \pm 1$ then after upto $k - 1$ squarings the 6575value must be equal to $-1$. The squarings are stopped as soon as $-1$ is observed. If the value of $1$ is observed first it means that 6576some value not congruent to $\pm 1$ when squared equals one which cannot occur if $n$ is prime. 6577 6578\begin{figure}[!here] 6579\begin{small} 6580\begin{center} 6581\begin{tabular}{l} 6582\hline Algorithm \textbf{mp\_prime\_miller\_rabin}. \\ 6583\textbf{Input}. mp\_int $a$ and $b$, $a \ge 2$, $0 < b < a$. \\ 6584\textbf{Output}. $c = 1$ if $a$ is a Miller-Rabin prime to the base $a$, otherwise $c = 0$. \\ 6585\hline 65861. $a' \leftarrow a - 1$ \\ 65872. $r \leftarrow n1$ \\ 65883. $c \leftarrow 0, s \leftarrow 0$ \\ 65894. While $r.used > 0$ and $r_0 \equiv 0 \mbox{ (mod }2\mbox{)}$ \\ 6590\hspace{3mm}4.1 $s \leftarrow s + 1$ \\ 6591\hspace{3mm}4.2 $r \leftarrow \lfloor r / 2 \rfloor$ \\ 65925. $y \leftarrow b^r \mbox{ (mod }a\mbox{)}$ \\ 65936. If $y \nequiv \pm 1$ then \\ 6594\hspace{3mm}6.1 $j \leftarrow 1$ \\ 6595\hspace{3mm}6.2 While $j \le (s - 1)$ and $y \nequiv a'$ \\ 6596\hspace{6mm}6.2.1 $y \leftarrow y^2 \mbox{ (mod }a\mbox{)}$ \\ 6597\hspace{6mm}6.2.2 If $y = 1$ then goto step 8. \\ 6598\hspace{6mm}6.2.3 $j \leftarrow j + 1$ \\ 6599\hspace{3mm}6.3 If $y \nequiv a'$ goto step 8. \\ 66007. $c \leftarrow 1$\\ 66018. Return(\textit{MP\_OKAY}). \\ 6602\hline 6603\end{tabular} 6604\end{center} 6605\end{small} 6606\caption{Algorithm mp\_prime\_miller\_rabin} 6607\end{figure} 6608\textbf{Algorithm mp\_prime\_miller\_rabin.} 6609This algorithm performs one trial round of the Miller-Rabin algorithm to the base $b$. It will set $c = 1$ if the algorithm cannot determine 6610if $b$ is composite or $c = 0$ if $b$ is provably composite. The values of $s$ and $r$ are computed such that $a' = a - 1 = 2^sr$. 6611 6612If the value $y \equiv b^r$ is congruent to $\pm 1$ then the algorithm cannot prove if $a$ is composite or not. Otherwise, the algorithm will 6613square $y$ upto $s - 1$ times stopping only when $y \equiv -1$. If $y^2 \equiv 1$ and $y \nequiv \pm 1$ then the algorithm can report that $a$ 6614is provably composite. If the algorithm performs $s - 1$ squarings and $y \nequiv -1$ then $a$ is provably composite. If $a$ is not provably 6615composite then it is \textit{probably} prime. 6616 6617\vspace{+3mm}\begin{small} 6618\hspace{-5.1mm}{\bf File}: bn\_mp\_prime\_miller\_rabin.c 6619\vspace{-3mm} 6620\begin{alltt} 6621\end{alltt} 6622\end{small} 6623 6624 6625 6626 6627\backmatter 6628\appendix 6629\begin{thebibliography}{ABCDEF} 6630\bibitem[1]{TAOCPV2} 6631Donald Knuth, \textit{The Art of Computer Programming}, Third Edition, Volume Two, Seminumerical Algorithms, Addison-Wesley, 1998 6632 6633\bibitem[2]{HAC} 6634A. Menezes, P. van Oorschot, S. Vanstone, \textit{Handbook of Applied Cryptography}, CRC Press, 1996 6635 6636\bibitem[3]{ROSE} 6637Michael Rosing, \textit{Implementing Elliptic Curve Cryptography}, Manning Publications, 1999 6638 6639\bibitem[4]{COMBA} 6640Paul G. Comba, \textit{Exponentiation Cryptosystems on the IBM PC}. IBM Systems Journal 29(4): 526-538 (1990) 6641 6642\bibitem[5]{KARA} 6643A. Karatsuba, Doklay Akad. Nauk SSSR 145 (1962), pp.293-294 6644 6645\bibitem[6]{KARAP} 6646Andre Weimerskirch and Christof Paar, \textit{Generalizations of the Karatsuba Algorithm for Polynomial Multiplication}, Submitted to Design, Codes and Cryptography, March 2002 6647 6648\bibitem[7]{BARRETT} 6649Paul Barrett, \textit{Implementing the Rivest Shamir and Adleman Public Key Encryption Algorithm on a Standard Digital Signal Processor}, Advances in Cryptology, Crypto '86, Springer-Verlag. 6650 6651\bibitem[8]{MONT} 6652P.L.Montgomery. \textit{Modular multiplication without trial division}. Mathematics of Computation, 44(170):519-521, April 1985. 6653 6654\bibitem[9]{DRMET} 6655Chae Hoon Lim and Pil Joong Lee, \textit{Generating Efficient Primes for Discrete Log Cryptosystems}, POSTECH Information Research Laboratories 6656 6657\bibitem[10]{MMB} 6658J. Daemen and R. Govaerts and J. Vandewalle, \textit{Block ciphers based on Modular Arithmetic}, State and {P}rogress in the {R}esearch of {C}ryptography, 1993, pp. 80-89 6659 6660\bibitem[11]{RSAREF} 6661R.L. Rivest, A. Shamir, L. Adleman, \textit{A Method for Obtaining Digital Signatures and Public-Key Cryptosystems} 6662 6663\bibitem[12]{DHREF} 6664Whitfield Diffie, Martin E. Hellman, \textit{New Directions in Cryptography}, IEEE Transactions on Information Theory, 1976 6665 6666\bibitem[13]{IEEE} 6667IEEE Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Std 754-1985) 6668 6669\bibitem[14]{GMP} 6670GNU Multiple Precision (GMP), \url{http://www.swox.com/gmp/} 6671 6672\bibitem[15]{MPI} 6673Multiple Precision Integer Library (MPI), Michael Fromberger, \url{http://thayer.dartmouth.edu/~sting/mpi/} 6674 6675\bibitem[16]{OPENSSL} 6676OpenSSL Cryptographic Toolkit, \url{http://openssl.org} 6677 6678\bibitem[17]{LIP} 6679Large Integer Package, \url{http://home.hetnet.nl/~ecstr/LIP.zip} 6680 6681\bibitem[18]{ISOC} 6682JTC1/SC22/WG14, ISO/IEC 9899:1999, ``A draft rationale for the C99 standard.'' 6683 6684\bibitem[19]{JAVA} 6685The Sun Java Website, \url{http://java.sun.com/} 6686 6687\end{thebibliography} 6688 6689\input{tommath.ind} 6690 6691\end{document} 6692