Abstract:
A method and apparatus are disclosed for performing modular multiplication. Modular multiplication in accordance with the present invention includes precalculating a 2&#39;s complement of a given modulus and multiples of the 2&#39;s complement and calculating a total magnitude of end-around carries during the modular multiplication. The calculated multiples are selected depending on the total magnitude of the end-around carries, and the selected multiples are added. The disclosure includes array structures in accordance with the present invention. The invention includes an algorithm designed for Rivest-Shamir-Adelman (RSA) cryptography and based on the familiar iterative Homer&#39;s rule, but uses precalculated complements of the modulus. The problem of deciding which multiples of the modulus to subtract in intermediate iteration stages has been simplified using simple look-up of precalculated complement numbers, thus allowing a finer-grain pipeline. Regularity and local connections make the algorithm suitable for high-performance array implementation in FPGA&#39;s (field programmable gate arrays) or deep submicron VLSI&#39;s.

Description:
BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The present invention relates generally to cryptography systems for performing encoded communication in various communication services such as wireless local area network communications, computer network communications or the like, and more particularly to a device and method of performing modular multiplication for key encryption. 
     2. Description of the Related Art 
     Cryptography systems have been growing in importance recently as a method for improving data security in a variety of communication services. In general, cryptography systems can be classified as one of two types: symmetric and asymmetric [W. Diffie and M. E. Hellman, &#34;New directions in cryptography&#34;, IEEE Trans. Inform. Theory, vol. IT-22, pp. 644-654, November 1976.; See also U.S. Pat. Nos. 4,351,982, 5,349,551, and 5,666,419]. 
     Symmetric cryptography systems use the same key (i.e., the secret key) to encrypt and decrypt a message. The symmetric cryptography systems are often called secret key cryptography (SKC) systems. Examples of SKC systems include DES (Data Encryption System) which is set as a standard by U.S. Commerce Department, IDEA (International Data Encryption Algorithm) [X. Lai and J. L. Massey, &#34;A proposal for a new block encryption standard&#34;, in EUROCRYPT &#39;90, Aarhus, Denmark, Mark 1990.; R. Zimmermann et al, &#34;5 Å, 177 Mb/s VLSI implementation of International data encryption algorithm&#34;, IEEE J. Solid-State Circuits. vol. 29, pp. 303-307. March 1994.], or the like. A problem encountered in the use of SKC systems is the difficulty in the transport of the secret key from the sender to the recipient in a secure and tamperproof fashion. If the secret key could be sent securely, the SKC system would not be needed in the first place because one would simply use that same secure channel to send his message. Frequently, trusted couriers are used as a solution to this problem. Another, more efficient and reliable solution is asymmetric cryptography system. 
     Asymmetric cryptography systems, called public key cryptography (PKC) systems, use one key (i.e., the public key) to scramble a message and a different key (the private key) to descramble it. These two keys are produced on the basis of mathematics. That is, the keys are mathematically related to each other. The public key is made available to anyone that wishes to use it, while the private key is maintained secretly by the owner. PKC systems are generally preferred over traditional SKC systems, which are presently the standard data encryption technique. PKC systems employ safer key distribution. 
     The Rivest-Shamir-Adelman (RSA) system [R. L. Rivest, A. Shamir, and L. Adelman, &#34;A method for obtaining digital signatures and public-key cryptosystems&#34;, Commun. ACM, vol. 21, pp. 120-126, February 1978.] is one of the most widely used public key cryptography systems. The core arithmetic operation in RSA cryptography is modular multiplication over a positive integer. Modular multiplication is also a major computation of residue number systems [F. J Tayer, &#34;Residue arithmetic: A tutorial with examples&#34;, IEEE Comput. Mag., vol. 17, pp. 50-62, May 1984.] as well as other cryptography systems such as IDEA, and Diffie-Hellman key exchange [W. Diffie and M. E. Hellman, &#34;New directions in cryptography,&#34; IEEE Trans. Inform., vol. IT-ww, pp. 644-654, November 1976.]. 
     The modular multiplication is represented as follows: 
     
         F=A×C mod C                                          (1) 
    
     where, A, B and C are n-bit integers. 
     Modular multiplication is generally considered a complicated arithmetic operation because of the inherent multiplication and division operations. There are two main approaches to computing modular multiplication: 1) perform the modulo operation after multiplication or 2) during multiplication. The modulo operation is accomplished by integer division in which only the remainder is needed for further computation. 
     The first approach requires an nxn bit multiplier with a 2n-bit register followed by a 2n×n bit divider. In the second approach, the modulo operation occurs in each iteration step of integer multiplication. The second approach requires only an n×n bit multiplier since the modulo operation performed on the partial product by using a carry-save adder scheme where carries produced in intermediate iteration stages are stored and then propagated in the last stage [C. K. Koc and C. Y. Hung, &#34;Carry-Save Adders for Computing the Product AB Modulo N&#34;, Electronics Letters, vol. 26, No. 13, pp. 899-900, Jun. 21, 1990.; J. Koren, &#34;Computer Arithmetic Algorithm&#34;, Englewood Cliffs, N.J.: Prentice-Hall, 1993]. The second approach, therefore, requires more addition/substraction computations due to O(n) modulo reduction steps (while the first approach requires more hardware), thereby resulting in long carry chains, which in turn cause latency and lengthy clock cycles. 
     Numerous proposals involving both approaches have focused on the fast calculation of a long carry chain. Redundant number systems and a higher radix carry-save form are some of the different number representations that have been used for this purpose [N. Takagi, &#34;A radix-4 modular multiplication hardware algorithm for modular exponentiation&#34;, IEEE Trans. Comput., vol. 41, pp. 949-956, August 1992; A. Vandemeulebroecke et al., &#34;A new carry-free division algorithm and its application to a single chip 1024-b RSA processor&#34;, IEEE J. Solid-State Circuit&#34;, vol. 25, pp.748-755, June 1990.]. A carry prediction technique has also been used for fast calculation of modular multiplication [E. B. Brickell, &#34;A fast modular multiplication algorithm with application to two key cryptography&#34;, in Advances in Cryptology, Proceedings of Crypto 82, New York: Plenum, 1982, pp. 51-60.]. 
     Since PKC was introduced, many algorithms and hardware structures have been proposed for modular multiplication [S. E. Eldridge and D. Walter, &#34;Hardware implementation of Montgomery&#39;s modular multiplication algorithm&#34;, IEEE Trans. Comput., vol. 42, pp. 693-699, June 1993.]. Several array structures suited for VLSI implementation have also been discussed. [S. E. Eldridge and D. Walter, &#34;Hardware implementation of Montgomery&#39;s modular multiplication algorithm&#34;, IEEE Trans. Comput., vol. 42, pp. 693-699, June 1993.; C. K. Koc and C. Y. Hung, &#34;Bi-level systolic arrays for modular multiplication&#34;, J. VLSI Sig. Proc., vol. 3, pp. 215-223, 1991; A. Vandemeulebroecke et al., &#34;A new carry-free division algorithm and its application to a single chip 1024-b RSA processor&#34;, IEEE J. Solid-State Circuit, vol. 25, pp. 748-755, June 1990.]. The disclosure of these articles are incorporated herein by reference for better understanding of the related art. Vandemeulebroecke et al. use a modulo after multiplication approach using a signed digit number representation. It consists of two arrays: one for multiplication and the other for integer division. Koc and Hung apply Blackey&#39;s algorithm [G. R. Blackey, &#34;A computer algorithm for the product AB modulo M,&#34; IEEE Trans. Comput., vol. 32, pp.497-500, 1983] and use a sign-estimation method by looking at the five most significant bits at each iteration stage. Although they derive a bit-level systolic array structure, the latency and clock cycle are relatively long due to the control node which estimates the sign of the intermediate result in each stage. 
     Eldridge and Walter use Montgomery&#39;s algorithm which only works if the modulus is relatively prime to the radix, although this is always the case in RSA. 
     The above techniques suffer from a drawback that hardware overhead due to their algorithm traits is large, inhibiting them from being put to practical use. 
     Consequently, a matter of major concern in providing enhanced performance in data encryption systems is directed to modulo operations. More specifically, on how to reduce critical path delay due to long carry chains for the purpose of operational speed improvement and simplified hardware implementation. Improving the long critical path delay on modulo operation depends on how fast carries in the most significant bits (MSBs) required for n-bit substraction can be processed and how much the amount of carry computation can be reduced, since the modulo operation of the modular multiplication is performed by integer division and the division is carried out by consecutive subtractions. 
     To satisfy the ever growing security requirements of high-speed communications, such as personal communication services and wireless local area networks, a VLSI hardware encryption solution is needed because of 1) high throughput requirement, 2) low-power requirements, 3) a high-volume market, 4) the computation is poorly suited to microprocessors or DSP&#39;s, and 5) the problem size is expected to continue to grow. 
     SUMMARY OF THE INVENTION 
     It is therefore an object of the present invention to provide a modular multiplier which is suitable for high speed cryptography systems. 
     It is another object of the present invention to provide a modular multiplier which can be fully pipelined for high performance and can also be easily mapped to linear arrays for various space/time tradeoffs. 
     It is still another object of the present invention to provide a modular multiplier which has a systolic structure adapted for actual use in VLSI architecture. 
     It is still another object of the present invention to provide a method capable of performing data encryption using high speed modular multiplication. 
     To attain the above objects, there are provided novel methods and array structures for performing integer modular multiplication, with application to, but not restricted to, RSA encryption systems. 
     In one method for performing modular multiplication in accordance with the present invention, a step of precalculating a 2&#39;s complement of a given modulus and multiples of the 2&#39;s complement and calculating a total magnitude of end-around carries during modular multiplication are included. Then, by selecting the calculated multiples depending on the total magnitude of the end-around carries and adding the selected multiples modular multiplication in accordance with the present invention is performed. 
     A device for performing modular multiplication includes means for precalculating a 2&#39;s complement of a given modulus and multiples of the complement. Also included are means for storing the multiples and means for selecting the calculated multiples depending on a total magnitude of the end-around carries produced during the modular multiplication and means for adding the selected multiples. 
     An array structure for iteration stages of a modular multiplier in accordance with the present invention includes first, second and third control nodes arranged in a first direction for controlling processing nodes. A first group of processing nodes is placed side by side with the first control node and arranged in a second direction which is orthogonal to the first direction, for performing same operations. A second group of processing nodes is placed side by side with the second control node and arranged in the second direction, for performing same operations. A third group of processing nodes is placed side by side with the third control node and arranged in the second direction, for performing same operations. 
     Another array structure for iteration stages of a modular multiplier in accordance with the present invention includes first, second and third control nodes arranged in a first direction for controlling processing nodes. First, second and third processing nodes are arranged in parallel and in the first direction. A first group of processing nodes is placed between the first control node and the first processing node and arranged in a second direction which is orthogonal to the first direction, for performing same operations. A second group of processing nodes is placed between the second control node and the second processing node and arranged in the second direction, for performing same operations. A third group of processing nodes is placed between the third control node and the third processing node and arranged in the second direction, for performing same operations. 
     The method of the present invention uses a carry-save-adder (CSA) scheme. Modulo reduction is performed on each intermediate partial product which results in an output in carry-save format. Regularity and local connections make the method suitable for high-performance array implementation in FPGA&#39;s (field programmable gate arrays) or deep submicron VLSI&#39;s. The array structures of the present invention employ a plurality of processing nodes. 
     The processing nodes in each of the embodiments of the present invention can be realized with simple encoders including just one or two full adders and a simple multiplexer. The stored complement numbers need to be precalculated only when the modulus is changed, thus not affecting the performance of the main computation. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     A more complete appreciation of the present invention, and many of the attendant advantages thereof, will become readily apparent as the same becomes better understood by reference to the following detailed description when considered in conjunction with the accompanying drawings in which like reference symbols indicate the same or similar components, wherein: 
     FIG. 1 is a diagram illustrating an iteration stage for the modular multiplication according to this invention; 
     FIG. 2A is a dependence graph illustrating an array structure for the modular multiplication according to an embodiment of the present invention; 
     FIGS. 2B to 2G are diagrams illustrating individual node elements employed in the array structure depicted in FIG. 2A and formed in accordance with the present invention; and 
     FIG. 3 is a dependence graph illustrating an alternate embodiment of an array structure for a modular multiplier formed in accordance with the present invention. 
    
    
     DESCRIPTION OF PREFERRED EMBODIMENTS 
     The present invention employs novel array architectures including architecture facilitating VLSI implementation and enhanced operating methods for performing modular multiplication to provide enhanced data encryption performance. In contrast to Montgomery&#39;s modular multiplication approach, for a better understanding of the present invention, a detailed derivation of the underlying algorithms used to practice the present invention is provided in the following section. 
     Two novel VLSI array architectures for modular multiplication are provided. The idea is similar to Montgomery&#39;s algorithm in which he tries to make each partial product a multiple of the radix to simplify the multiplication by the radix just by shifting) by only looking at the least significant bits (LSB), thus requiring a post-processing step to get the fmal answer. In this application, the most significant bits (MSB) are used to remove higher bit positions while keeping the correct answer in each partial product, keeping it within a predetermined range. Due to the simple translation of the modulo operation into an addition of a precalculated component of the modulus, the modulo during multiplication approach is used with a carry-save adder structure. Multiplexers are provided to choose the precalculated integer depending on a control which is generated in the leftmost node in each stage. Compared to previous works, it is possible to obtain a higher clock frequency mainly owing to the simplified modulo reduction operation. 
     Derivation of Algorithms for use with the Present Invention 
     In RSA encryption, the encryption key, or modulus, is a product of two large prime numbers, usually more than 500 bits and should be changed periodically for security reasons. In practice, the key is updated infrequently, for example every few months, weeks, or days, depending on the security requirements. The present invention takes advantage of this fact by providing array modular multipliers which use precomputation of values which are stored and recalled from a look-up table. 
     The basic concept for the modulo reduction operation according to this invention will be explained and an iterative algorithm will be described in detail in this section. Array structures corresponding to this algorithm will be discussed with reference to the accompanying drawings in a following section. 
     The basic equation for modulus multiplication is stated as: 
     
         F=A×B mod C                                          (1) 
    
     where A, B, C and F are unsigned n-bit integers. The n-bit modulus C is presented by a binary number system as ##EQU1## where c i  εGF(2). 
     In a modulus multiplication algorithm of the present invention, the complement of the n-bit modulus C and its multiples are precalculated and stored, rather than being dynamically calculated during each operation. The 2&#39;s complement, K, of the modulus C is defined as follows: 
     
         K.tbd.2.sup.n mod C                                        (2) 
    
     In other words, any carry of weight 2 n  can be replaced by an addition of K, which means that the end-around carry implies an extra addition. If K does not change frequently, it is possible to precalculate multiples of K and store them in registers for use in the modulo reduction operation. Note that if the MSB of C is 1, K is equivalent to -C in a 2&#39;s complement number system. 
     To simplify the description of a modular multiplication algorithm using the modulo during multiplication approach according to this invention, a new variable, K h , is introduced to handle multiple end-around carries, i.e., multiples K h  of K. K h  is defined as follows: 
     
         K.sub.h .tbd.h×K mod C                               (3) 
    
     where h is a positive integer (1, 2, . . . ). 
     From equations (2) and (3), it can be appreciated that 2 n+j  mod C is equal to 2 j  ·K mod C. 
     Carries can also appear in a combined mode. That is, carries of weight (or bit position) n+1, n+2, etc., as well as carry of weight n, will be generated, and can be represented in the above manner. As an example, if two carries of weight 2 n+1  and one carry of weight 2 n  are generated, then (2 n+1  +2 n+1  +2 n ) mod C=5·2 n  mod C=5·K mod C=K 5 . Thus, when multiples K h  of K have been precalculated and stored in registers, the terms greater than 2 n  in the carry save addition (CSA) scheme, i.e., carries and sums, can be replaced by the multiples K h . The value of term h for each K h  term is calculated in a corresponding iteration stage of the modulo during multiplication. The corresponding K h  term is selected by means of a multiplexer according to the MSB state of the partial product. In an RSA encryption algorithm, since the modulus C (i.e., key) typically does not change for a long time, K h  can be precalculated. But, when the key is changed, the K h  terms have to be updated. 
     The modular multiplication of equation (1) can be described by an iterative procedure known as Horner&#39;s rule, which can be stated as follows: ##EQU2## 
     Equation (4) can be described in a recursive form as follows: 
     
         P.sub.0 =0 
    
     
         P.sub.i =2P.sub.i-1 +b.sub.n-1 A mod C                     (5) 
    
     where, P i  is a partial product. 
     The present invention uses a CSA scheme while performing integer multiplication to reduce a carry propagation penalty. In the CSA scheme, a partial sum and a carry sequence are generated in intermediate stages and the carry propagation occurs only at the last stage. The basic element of the CSA scheme is a full adder (FA) which is often called a (3, 2) counter. The full adder accepts three inputs, referred to here as s i , c i , x i  (associated with weight 2 i ), and produces two outputs, carry c o  (with weight 2 i+1 ) and sum s o  (with weight 2 i ). The arithmetic operation of the (3, 2) counter can thus be described by the familiar expression: 
     
         2c.sub.o +s.sub.o =s.sub.i +c.sub.i +x.sub.i               (6) 
    
     where &#34;+&#34; means an algebraic (not Boolean) addition. 
     Using the CSA scheme, a carry of weight 2 n  in the leftmost node in each stage can be obtained. As shown in equation (1), this carry can be replaced by the addition of the integer K for a modulo operation. 
     From equation (5), a partial product P i  can be denoted by 
     
         P.sub.i .tbd.2C.sub.i +S.sub.i                             (7) 
    
     then, the valid range of P i  is 0≦P i  ≦3·2 n  -3. This means P i  is allowed to be greater than modulus C at intermediate stages. 
     Equation (3) contains two modulo reduction steps and can be written by introducing a new partial product term T i  as follows: 
     &lt;Algorithm I&gt; 
     i) T i  =2P i-1  mod C 
     ii) P i  =(T i  +b n-1  A) mod C 
     But, step ii) cannot be implemented by the CSA scheme because it has four operands to be added. Note that the modulo operation implies at least one extra addition of K. This can be solved by dividing the step ii) into two steps as: 
     &lt;Algorithm II&gt; 
     i) T i  =2P i-1  mod C 
     ii-a) T i  *=T i  +b n-1  A 
     ii-b) P i  =T i  *mod C 
     In step i) of the algorithm II, 2P i-1  implies one 2 n+1  term (i.e., a carry c i-1   n-1  of bit position n-1) and two 2 n  terms (i.e., a sum s i-1   n-1  of bit position n-1 and a carry c i-1   n-2  of bit position n-2), which can generate a maximum of 4·2 n . In step ii-a), the modulo operation cannot be performed because there are already three operands: two from T i  in carry save form, and one for A depending on b n-i . Instead it is desirable to pass through the MSB carry of T i  to step ii-b). So, in step ii-b), at most 2·2 n  (one passed from T i  and another newly generated in T i  *) will be obtained as end-around carries. In both the steps i) and ii-b), only one additional operand is allowed. That is why the K h  &#39;s are precalculated instead of adding K multiple times. 
     To explain algorithm II more formally, σ(P i ) is defined as follows: 
     
         σ(P.sub.i).tbd.P.sub.i -h=2.sup.n +K.sub.h           (8) 
    
     where, h=f(x 1 , x 2 , x 3 , . . . , x r ) and the function f (·) calculates the total magnitude of end-around carries, and x 1 , x 2 , x 3 , . . . , x r  are bit variables (always carries and sums of the MSB position) which contribute to the translation of equation (1). Thus the function f (·) can be described as: ##EQU3## where α k  =1 if x k  has weight 2 n , α k  =2 if the weight is 2 n+1 , α k  =4 if the weight is 2 n+2 , and so on. In other words, σ(P i ) replaces h·2 n  with K h  which is precalculated. 
     Using equation (8), algorithm II can be rewritten as follows: 
     &lt;Algorithm III&gt; 
     i) T i  =2P i-1  mod C 
     ii-a) T i  *=T i  +b n-1  A 
     ii-b) P i  =σ(T i  *) 
     Array Structure Embodiments 
     The algorithms just described can be implemented by processing arrays formed in accordance with the present invention. FIG. 1 illustrates an iteration stage for performing modular multiplication according to this invention. As shown in the figure, the function f (·) of the above algorithm III is 
     for step i), f (·)=2c i-1   n-1  +s i-1   n-1  +c i-1   n-2   
     for step ii-b), f (·)=γ i   n-1  +γ i  * n-1   
     where γ i   n-1  and γ i*   n-1  are the MSB carries of T i  and T 1* , respectively, and both have the weight 2 n . 
     As described above, the calculation method of the function f (·) according to this invention is simplified compared to previous techniques so that the clock cycle can be reduced. If the transmittent signals are propagated to each processing node through other nodes, an array structure realizable as a parallel array multiplier, can be obtained. 
     FIG. 2A illustrates a single stage, locally-connected structure of a modular multiplier array formed in accordance with the present invention which can be directly implemented as a parallel array multiplier. Referring to FIG. 2A, the array multiplier includes a plurality of control nodes X1, X2 and X3. The control nodes X1, X2 and X3 are arranged in a first direction (column direction). 
     The array multiplier further includes a first group of processing nodes, referred to as A group processing nodes. Each A group processing node performs the same operations. A first A group processing node 20 is connected to the X1 control node. The balance of the A group processing nodes are arranged and interconnected in a side by side relationship and arranged in a second direction (i.e. a row direction), which is orthogonal to the first direction. 
     The array multiplier further includes a second group of processing nodes, referred to as B group processing nodes. A first B group processing node 22 is connected to the X2 control node. The balance of the B group processing nodes are interconnected in a side by side relationship and arranged in the second direction. Each of the B group processing nodes perform the same operations. 
     The array multiplier illustrated in FIG. 2A further includes a third group of processing nodes, referred to as C group processing nodes. A first C group processing node 24 is connected to the X3 control node. The balance of the C group processing nodes are interconnected in a side by side relationship and arranged in the second direction. Each of the B group processing nodes perform the same operations. 
     FIGS. 2B to 2G are diagrams illustrating the functions of the nodes of FIG. 2A. In FIGS. 2B to 2G, &#34;*&#34;, &#34;+&#34; and &#34;&amp;&#34; represent algebraic multiplication, algebraic addition and Boolean AND logic operation, respectively. Referring to FIG. 2B, control node X1 receives a first carry (c1), a second carry (c2) and a sum (s) signal as input parameters and provides an output (to). Control node X1 implements the function: to=2*c1+s+c2, which is used to calculate the control value h from the equation h=f(x 1 , x 2 , x 3 , . . . , x r ) and the function f (·) calculates the total magnitude of end-around carries where x 1 , x 2 , x 3 , . . . , x r  are bit variables (always carries and sums of the MSB position which are represented by c&#39;s and s&#39;s in the FIGS.). A simple encoder circuit can be formed to implement control node X1. 
     The operation of control node X2 is illustrated in FIG. 2C. Control node X2 essentially functions to pass signals through without processing. Control node X2 receives inputs b and c and provides outputs bo and so. Control node X2 is characterized by the equations bo=b and so=c. Accordingly, this control node can be implemented as a pair of wired connections. 
     Referring to FIG. 2D, the operation of control node X3 will be described. Control node X3 operates with control node X1 to calculate the control value h as described above. Control node X3 receives a carry input (c) and a sum input (s) and provides an output, to=s+c. As with the control node X1, control node X3 can be implemented using a simple encoder circuit. 
     FIG. 2E graphically illustrates the operation of the A group processing nodes. Each A group processing node receives signals ti, ki[1:4], ai, si and ci as input variables and generates output signals to, ao, co, so and ko[1:4]. The A group processing nodes pass the signals ti and ai, performing the functions: to=ti and ao=ai. In addition, each of the A group processing nodes perform the function: (co,so)=FA(si,ci,ki[ti]). These functions can be implemented using a full adder (FA) with a 4×1 multiplexer and an AND gate. 
     FIG. 2F graphically illustrates the operation of the B group processing nodes. Each B group processing node receives bi, ki[1:4], ai, si and ci as input variables and generates output signals bo, ao, co, so and ko[1:4]. The B group processing nodes pass the signals bi and ai, performing the functions: bo=bi and ao=ai. In addition, each of the B group processing nodes performs the function: (co,so)=FA(si,ci,ai&amp;bi). These functions can be implemented using a full adder (FA) with an AND gate. 
     FIG. 2G graphically illustrates the operation of the C group processing nodes. Each C group processing node receives ai, bi, ci, ti and ki[1:4] as input variables and generates output signals ao, co, so and ko[1:4]. The C group processing nodes pass the signals ti and ai, performing the functions: to=ti and ao=ai. In addition, each of the C group processing nodes performs the function: (co,so)=FA(si,ci,ki[ti]). These functions can be implemented using a full adder (FA) with a 2×1 multiplexer and an AND gate. The AND gate is needed in both the A group processing nodes and the C group processing nodes to accept K 0  =0 when the control value h is zero. The output of control nodes X1 and X3 are used to select the appropriate K h  (i.e. ki [1:4]) value from multiplexers in the processing nodes A and C, respectively. 
     The multiplexers of the A group processing nodes and the C group processing nodes are controlled by the X1 and X3 control nodes, respectively. In the embodiment of FIG. 2A, there exists a systolic schedule which is not linear due to its skewed connection between the stages. 
     An example of the operation of the present invention can be illustrated with reference to Table I. Table I presents an example of the present modular multiplication algorithm using n=12, with A=010001000100(=1092), B=010011001101(=1229), and C=100000101001 (=2089). The K h  &#39;s are precalculated as K 3  =K=011111010111(=2007), K 2  =011110000101(=1925), K 3  =011100110011(=1843), and K 4  =011011100001(=1761). From equation (7), the final output is ##EQU4## which equals 930 after modulo reduction to 
     
                       TABLE I______________________________________stage       (carry, sum)         f()   b.sub.n-1______________________________________0    P.sub.0       00 00 00 00 00 00 00 00 00 00 00 001    T.sub.1       00 00 00 00 00 00 00 00 00 00 00 00T.sub.1       00 00 00 00 00 00 00 00 00 00 00 00                            f(•) = 0                                  0P.sub.1       00 00 00 00 00 00 00 00 00 00 00 00                            f(•) = 02    T.sub.2       00 00 00 00 00 00 00 00 00 00 00 00T.sub.2       00 01 00 00 01 01 00 00 01 01 00 01                            f(•) = 0                                  1P.sub.2       00 01 00 00 01 01 00 00 01 01 00 01                            f(•) = 03    T.sub.3       01 00 00 01 01 00 00 01 01 00 01 00T.sub.3       01 00 00 01 01 00 00 01 01 00 01 00                            f(•) = 0                                  0P.sub.3       01 00 00 01 01 00 00 01 01 00 01 00                            f(•) = 04    T.sub.4       00 01 10 10 01 01 01 10 00 10 01 01T.sub.4       00 10 01 00 01 01 10 00 01 00 01 01                            f(•) = 1                                  0P.sub.4       01 00 01 00 01 10 00 00 01 00 01 01                            f(•) = 05    T.sub.5       00 01 01 11 01 01 00 10 00 10 10 01T.sub.5       01 00 10 01 01 01 01 00 01 01 00 01                            f(•) = 1                                  1P.sub.5       01 01 00 01 01 01 01 00 01 01 00 01                            f(•) = 06    T.sub.6       01 01 10 10 10 10 00 10 01 01 10 01T.sub.6       01 11 01 01 10 01 01 00 10 11 00 10                            f(•) = 1                                  1P.sub.6       10 01 01 10 00 01 01 01 01 01 01 00                            f(•) = 07    T.sub.7       01 11 01 01 10 01 01 01 01 10 00 10T.sub.7       10 01 01 10 00 01 01 01 10 00 00 01                            f(•) = 2                                  0P.sub.7       00 10 11 01 01 10 01 11 00 01 01 10                            f(•) = 18    T.sub.8       01 10 10 11 01 11 01 01 01 11 01 01T.sub.8       10 01 01 01 10 01 01 01 10 01 01 01                            f(•) = 1                                  0P.sub.8       00 10 10 11 01 10 01 11 00 10 10 10                            f(•) = 19    T.sub.9       01 10 10 11 01 11 01 10 01 10 01 01T.sub.9       10 01 01 01 10 01 10 00 10 00 01 01                            f(•) = 1                                  1P.sub.9       00 10 10 11 01 11 00 10 00 01 10 10                            f(•) = 110   T.sub.10       01 10 10 11 10 11 00 01 10 10 01 01T.sup.*.sub.10       10 10 01 10 10 01 00 10 10 01 01 10                            f(•) = 1                                  1P.sub.10       01 01 11 10 01 10 01 10 00 10 11 01                            f(•) = 111   T.sub.11       10 11 01 11 01 11 00 10 01 10 10 01T.sup.*.sub.11       01 01 10 01 10 01 01 00 10 01 00 01                            f(•) = 1                                  0P.sub.11       01 11 01 11 01 10 01 10 00 10 01 10                            f(•) = 112   T.sub.12       01 11 10 11 01 10 00 01 00 11 00 01T.sub.12       10 10 01 01 10 00 00 01 01 01 00 01                            f(•) = 2                                  1P.sub.12       01 01 10 10 01 01 00 10 01 10 01 10                            f(•) = 1______________________________________ 
    
     The array topology of FIG. 2A can be simplified by merging two adjacent processing nodes into one within each group of processing nodes. This is shown in FIG. 3. Referring to FIG. 3, the array includes three rows of processing nodes. These are AA group processing nodes, BB group processing nodes and CC group processing nodes. Each of the processing nodes in these groups have two A, B and C type processing nodes, respectively. This topology provides a linear systolic schedule (along a scheduling hyperplane as indicated in FIG. 3) and is more suitable for implementation in VLSI architecture. If the word length n is an even number, then all nodes except the control nodes will be merged nodes. However, as shown in FIG. 3, if n is an odd number, single nodes A, B and C will remain in the LSB place. 
     From the embodiments illustrated in FIGS. 2A and 3, those skilled in the art will appreciate that many different one-dimensional arrays (e.g., bit-serial modulo multiplier) can be obtained depending on the mapping functions. 
     In the array structures of the present invention, the control signals are generated by control nodes which occupy the leftmost node position, The control nodes are formed with a simple architecture which include just four gates (two XOR, one AND, one NOR gate) or two gates (one XOR and one NOR gate). The simplicity of the control nodes gives a much faster clock cycle for the entire array. Thus, in the present invention, it is not the control node, but the processing node which determines the clock cycle. Therefore, higher processing speeds can be achieved. Note that all signals in FIG. 2A except the carry c 0  and sum s 0  are transmittent signals, which means they are not modified while passing through the array, thus allowing for broadcasting.