Abstract:
The present invention relates to cryptographic systems, and particularly, public key cryptographic systems implemented in digital communication devices.

Description:
BACKGROUND OF THE INVENTION 
     Cryptographic systems are generally used when the sender wishes to insure the secrecy and authenticity of the messages to be sent. This is particularly true when the message is to be transmitted over a nonsecure channel, such as a radio or microwave communication link, which can be monitored at will by any adverse party. 
     The two requirements, secrecy and authenticity, are very different. For example, secrecy prevents the adverse party from deciphering the monitored or intercepted message to obtain the secret message, whereas authenticity assures the receiver of the message of the identity of the sender. For example, an airborne strike force needs a secure system to protect the secrecy of communications sent via radio or data link to the aircraft, and the aircraft needs to be able to authenticate the sender of the communication before responding thereto. 
     The two most significant developments of the past ten years in the field of cryptography have been the development of the data encryption standard (DES) and public key cryptography. The real significance of DES was not so much the algorithm itself, but the fact that a &#34;standard&#34; was established. DES is able to accommodate high data rates, in excess of ten million bps, but is dependent upon the distribution of an encryption key, which renders it susceptible to potentially fatal key distribution problems. That this is particularly true of covert operations wherein widely disbursed units, some of which may be in hostile territory, must be communicated with. 
     Public key cryptography has done much to obviate the key distribution problem. The two approaches that have received most attention are the RSA and Knapsack algorithms. A third approach proposed in the literature is the use of the linear Goppa code algorithm. The Knapsack algorithm, which was never commercially implemented, has recently been broken. The most popular system, the RSA algorithm, while it seems to be a strong shield for the data it protects, is extremely slow. The linear Goppa code algorithm possesses a high data rate, in excess of one million bps, and has been strongly indicated to be computationally secure. 
     The known public key encryption algorithms provide computationally secure encoding algorithms that can be read only by one who has generated and published the public key, or who has access to the decoding algorithm. However, public key systems, by their nature, do not provide simultaneous authentication. 
     A tutorial introduction to contemporary cryptography may be found in an article Privacy and Authentication: An Introduction to Cryptography by Diffie and Hellman, proceedings to the IEEE, Vol. 67, No. 3, Mar. 1979, Page 397-427. 
     U.S. Pat. No. 4,351,982 entitled RSA PUBLIC KEY DATA ENCRYPTION SYSTEM HAVING LARGE RANDOM PRIME NUMBER GENERATING MICROPROCESSOR OR THE LIKE, is representative of a number of patents which disclose and teach the use of an RSA Public Key algorithm for cryptographic systems.; 
     U.S. Pat. No. 4,218,582 entitled PUBLIC KEY CRYPTOGRAPHIC APPARATUS METHOD, is representative of a number of references which teach the use of the Knapsack algorithm in a public key cryptographic system. 
     The use of linear Goppa codes for a public key algorithm is taught in an article entitled &#34;A Public-Key Crypto System Based on Algebraic Coding Theory&#34;, published by R.J. McEliece, DSN Progress Report 42-44, Jet Propulsion Lab, California Institute of Technology, Pasadena, California, January-February, 1978. 
     U.S. Pat. No. 4,417,338 entitled CRYPTOGRAPHIC KEY SHARING CIRCUIT AND METHOD USING CODE CORRECTION, teaches the use of encoding the encryption key into a code vector which is corrupted by combining it with an error vector to yield a 0 corrupted code vector. The corrupted code vector is corrected by a combination of an error correcting code and the use of at least K of the secondary keys. 
     Historically, the error vector was viewed as an impediment to the communication process. A &#34;sender&#34; would generate a binary message vector v and send it through a communications channel. What the &#34;receiver&#34; got at the other end was often not the original message v, but rather v+e, that is, the message corrupted by channel induced errors. The goal of error correcting codes was to discover the error vector e and remove its affect from the received vector r=v+e to obtain the original message v. 
     The book Error Correcting Codes by Petersen &amp; Weldon, Jr., published by MIT Press, Cambridge, Massachusetts in 1972, provides an excellent summary of error correcting codes, particularly those intended for a digital communications environment. 
     SUMMARY OF THE INVENTION 
     It is an object of the present invention to provide a public key algorithm having the ability to provide data in a higher rate communications environment than is possible with other public key algorithms. 
     It is another object of the present invention to utilize the error correcting capability of Goppa codes to transmit a secondary or piggyback message. 
     It is another object of the invention to utilize the error correcting capability of Goppa codes to enable the transmission of computationally secure cryptograms over common carrier data links. 
     It is still another object of the invention to make use of a completely new class of error patterns, using preselected or &#34;heavyweight error&#34; patterns to provide secondary communications capability. Historically, the communications process has been concerned with &#34;lightweight&#34; error vectors, since a &#34;maximum likelihood&#34; of decoding identifies them as the most probable choices in the decoding process. 
     It is another object of the present invention to use linear binary multiple error correcting codes, in which error vectors are intentionally added to create cryptograms, to form a public key encryption system which provides a high degree of security. 
     Another object of the present invention is to use an encryption process in which the error correction capability of the associated error correcting code is used simultaneously to intentionally obscure or further encrypt sensitive information, and to correct errors which may be caused by the communications channel. 
     It is another object of the present invention to use an encryption process in which the error patterns, because they are intentionally chosen, may be associated with information which is transmitted by specialized bit patterns which comprise the error pattern vector. 
     It is another object of the present invention to use an encryption process in which the error patterns, because they are intentionally chosen, may correspond to any correctable heavyweight, that is, normally nonselected error pattern. 
     It is a further object of the present invention to provide a method of transmitting a cryptogram over a communications channel by means of a public key algorithm, wherein said method comprises a series of sequential steps, the first step being the construction of a first generator matrix associated with a preselected finite field and an irreducible degree s Goppa polynomial, said generator matrix defining an s error correcting code capability. After the first generator matrix is constructed, a scrambled generator matrix is constructed by matrix multiplication wherein said scrambled generator matrix is the product of a nonsingular matrix, said first generator matrix, and a permutation matrix. This scrambled generator matrix defines an equivalent s error correcting code. After the scrambled generator matrix is constructed, the message to be sent is converted to blocked binary form wherein the size of the block form corresponds to the number of rows in the scramble generator matrix. After the message has been blocked, it is encoded with the scrambled generator matrix by using matrix multiplication to form a code vector. After the code vector has been derived, a preselected error vector is added in component wise fashion using modular two arithmetic to generate a cryptogram. The cryptogram is then transmitted over a communications channel wherein the anticipated channel errors combined with the weight of the preselected error vector do not exceed the degree s error correcting capability of the selected Goppa code. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1(a) is a paradigm of a conventional prior art encryption scheme using a secret key known only to sender and receiver. 
     FIG. 1(b) is a paradigm of a prior art public key encryption system. 
     FIG. 2 is a block diagram of a public key encoding and encryption program utilizing the present invention. 
     FIG. 3 is a block diagram of a public key decoding and decryption program utilizing the present invention. 
     FIG. 4 is a diagrammatic flow chart of a part of the computer program illustrated in FIG. 3, illustrating the application of the Goppa decoding algorithm to the present invention. 
     FIG. 5 is a paradigm of the encryption system of the present invention. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
     The generic components of a conventional encryption scheme, as illustrated in FIG. 1(a), includes an encryption algorithm E, a decryption algorithm D, and a key K, all of which interact to transform plaintext (X) into ciphertext (Y), and then back again. Symbolically one writes 
     
         Ek(X)=Y 
    
     
         Dk(Y)=X 
    
     Both sender and receiver must possess a copy of the key (invariably a sequence of numbers). From a logical point of view, knowledge of the function E and the key K will permit one to decrypt (as well as encrypt). Similarly, knowledge of D and K will permit one to encrypt (as well as decrypt). Both sender and receiver have an equal understanding of both processes involved. With the passage of time, it is conservatively assumed that knowledge of the encryption scheme will become known, even to unauthorized personnel. For example, unauthorized personnel (eavesdroppers) will find out what sort of algorithm has been implemented. What they will not learn (hopefully) is the specific key which is in use at any one time. Thus, the active key in use at any given moment is truly the &#34;key&#34; to the system. This is the reason for the great need to protect keys in a conventional encryption system. 
     Such is not the case with public key systems. In a public key scheme, two algorithms are used which are strongly separated: one to encrypt and one to decrypt. The encryption algorithm E is made public, while the parameters which define the decryption algorithm D are kept secret by the originator of the system. The important aspect of the system is that even given the public knowledge of E, it is computationally difficult to derive D. There is no &#34;encryption key&#34; as used above in the conventional scheme. Thus E can be made public without compromising D. Assuming for the moment that such functions exist, consider the prior art encryption paradigm shown in FIG. 1(b). Assume that sender B, illustrated at 11 wishes to transmit secretly to receiver A, illustrated at 12 who has established a public key system. Label the algorithm with a subscript E 12  to indicate ownership, not a key. The difference between this diagram and the preceding description of conventional cryptography is the missing key distribution requirement. Sender 11 encrypts using receiver 12&#39;s public algorithm E 12  Transmission may now occur in any chosen manner, since only receiver 12 will be able to properly decrypt the ciphertext. The system is intrinsically more secure, since D 12  never leaves the possession of receiver 12. There is no dissemination of keys which must be kept secret. If sender 11 were to set up a similar type of scheme using different algorithms E 11  and D 11 , where E 11  is made public and D 11  kept secret, then a two-way conversation may follow. However, it should be noted that since the public key algorithms are public, secrecy will be preserved, but authenticity will not be assured, since a third party could use 11&#39;s public key and claim that he/she was 11. 
     To date, there have been two public key approaches which have received a great deal of technical attention. They are the Knapsack and RSA algorithms. The Knapsack algorithm is based upon a famous combinatorial problem which can be briefly summarized as follows. Given a knapsack and a collection of cans of various sizes, determine what combination of cans is required to exactly fill the knapsack. The encryption scheme based upon this problem was recently broken. The RSA algorithm is based upon the difficulty of factoring large integers. There are several comments to be made regarding the RSA scheme. Recent progress in the applications of elliptic functions has raised questions regarding the strength of the algorithm. Second, the application of networks of microprocessors to perform parallel processing has produced somequite rapid factoring of large numbers. In addition, the RSA algorithm, because of the nature of its internal arithmetic, is relatively slow (on the order of 5,000 bps). These developments have caused researchers to begin investigating alternative approaches to public key encryption implementation. 
     ERROR CORRECTING CODES 
     Information theory, of which the theory of error correcting codes is a subset, was discovered by C. Shannon in the late 1940&#39;s. One of its major results is a theorem which states that so long as one does not exceed the capacity of the communications channel, it is possible to encode/decode information in such a way as to achieve arbitrarily small error rates. During the 40 years since this discovery, significant effort has been expended searching for the codes promised by this famous existence theorem. While ultimate success has not been achieved, the work has produced some very good codes and, even more importantly, some very fast encoding/decoding algorithms. 
     In order to explain the basic workings of the encryption algorithm under consideration, the reader must possess a minimal understanding of error correcting codes. The following is a brief summary of the required elements. The book Error Correcting Codes, by Peterson and Weldon, Jr. published by MIT Press, Cambridge, Mass. in 1972 contains an excellent summary of error correction theory. 
     For a given n≧0, the set of binary n-tuples, together with the operations of modulo 2 vector addition and scalar multiplication by elements of GF(2), is an n-dimensional vector space. A subset, V, of this vector space is a linear code if it is a subspace of the vector space. Any set of basis vectors of the code V can be regarded as the rows of a matrix G, called the generator matrix. Each element in V can be expressed as a linear combination of the rows of G. If the dimension of the code (subspace) V is k, then G has k rows and V contains 2 k  code words or vectors. Such a code is called an (n,k) binary linear code of rate k/n. 
     To develop useful results, it is frequently necessary to have a unit of measure. Let u ε V be a code word. The Hamming weight of u,w(u), is defined to be the number of non-zero components of u. Let u,vεV be code words. The Hamming distance between u and v, d(u,v), is defined to be the number of components in which the two code words differ Hamming distance is a metric. The distance structure of a code is directly related to its error correcting capability. For some positive integer t, the code is a t-error correcting code if the distance between any two code words is at least d=2t+1. The minimum distance of a code is defined to be ##EQU1## But since the code is linear, the following is true 
     
         d(u,v)=d(u-v,o)=w(u-v) 
    
     and the problem of finding the minimum distance of a code is reduced to finding the minimum weight of the non-zero words. 
     FIG. 2 illustrates, in block diagram form, a public key encoding and encryption program utilizing an error correcting code, wherein the correcting capability of the code is used to corrupt information in the code word, and create a cryptogram. In the embodiment illustrated in FIG. 2, linear codes, and in particular, Goppa codes determined by irreducible polynomials are used. 
     When a message is encoded according to the present invention, the plaintext message m is first converted to binary form as indicated in functional step 15 in FIG. 2. The binary message is then formulated in blocks of k bits, m=(m 0 , m 1 ,...m k-1 ) as indicated at 16. Next, a code vector v is formed by multiplying the blocked message by the scrambled generator, matrix G&#39;, using matrix multiplication, m G&#39;=v, illustrated at functional step 17. 
     However, if encryption is desired, an error vector is added at step 18 
     
         v+e=r. 
    
     The code vector v is encrypted according to the present invention by adding an error vector e to v, using modulo 2 addition. 
     The received word r thus includes intentional errors, ##EQU2## 
     It is assumed, based on the previous choice of t, that the error vector e satisfies w(e)≦t. Since the code has a minimum distance d min  =2t+1, the received word r is closer to v than any other code word and one can successfully decode at the receive end of the communication channel. Thus if at most t errors occur, it is always possible for the originator of the scrambled matrix G&#39; to recover the original code word and plaintext message transmitted. 
     Decryption 
     FIG. 3 illustrated how the holder of the scrambled generator matrix G&#39; decrypts the received cryptogram r. 
     The received cryptogram r=v+e, indicated at 21 in FIG. 3 is first multiplied by the inverse of the secret permutation matrix P (used to form G&#39;) rP -1  to form: ##EQU3## 
     The Goppa decoding algorithm is then applied, as indicated at 23 in FIG. 3 to find mS, a word in the Goppa code. The decoding algorithm thus yields mS, and an error vector eP -1 . Then mS is multiplied by the inverse of S, S -1  to form: 
     
         mS S.sup.-1 =m 
    
     as indicated at 25 in FIG. 3. When m is recovered, it may then be unblocked and translated from binary to the plaintext message m. 
     The error vector eP -1  may also be recovered from the Goppa decoding algorithm as indicated at 27 in FIG. 3, by multiplying (eP -1 ) by the permutation matrix to yield e. 
     There are three (3) points to be made regarding the error vector e, at 18 in FIG. 2. 
     1. Since the decrypting process is actually a disguised error decoding process, the decryption may take place successfully as long as the number of errors in e does not exceed t. The sender may corrupt the code word v with only a portion of the t error bits, and permit the communication channel to (possibly) insert additional random errors up to the total number t. If the combined total of intentional and channel errors does not exceed t, successful decryption will result. This ability to both encrypt and tolerate communication channel errors is unique to this invention. 
     2. Since e is chosen by the sender, the contents of e may be made to correspond to a secondary message. This e is recoverable at the receive location, and thus the secondary message contained therein is also recoverable. This process has the effect of increasing the amount of information contained in r=v+e during the transmission process. If the error vector e is used to carry a secondary message, then it must be safeguarded from the insertion of communication channel errors (for example by separately protecting e with an error correcting code scheme). In particular, the contents of this secondary message contained in e may be made to correspond to authentication information unique to the sender. 
     3. Since the error vector e is chosen by the sender, additional error patterns other than those considered in classical error control processes may be utilized, Any correctable error pattern may be used which is capable of correction at the receive end of the communication channel. For example, classical communication theory assumes the presence of &#34;light weight errors&#34; which result from the application of maximum likelihood decoding assumptions. As described in Error Correcting Codes supra, there are other non-standard correctable error patterns which are not represened by patterns of minimum weight. An equally applicable set of &#34;heavy weight&#34; error vectors may be used where each heavy weight error (e&#39;) corresponds to the compliment of a light weight error vector (e) by 
     
         e=e+1=(e.sub.o, e.sub.l, ..., e.sub.n-1)+(1, 1, ..., 1), 
    
     the addition of the all-ones-vector. The expansion of the set of error patterns which may be used in the information corruption process causes an additional burden for the eavesdropper attempting to read the encrypted communication traffic. 
     The application of the Goppa Decoding Algorithm to the present invention, illustrated at 23 in FIG. 3 is more fully illustrated in the functional flow chart of FIG. 4, and described in detail in the attached Exhibit A 
     Exhibit A is a source listing of programs written in the Ada program language to demonstrate the present invention. The Ada language was selected in response to a desire on the part of the Department of Defense to standardize on one language While the program was written in Ada as a demonstration vehicle, it should be understood that many different languages could be used for this purpose 
     Exhibit A is a compilation of the major mathematical software needed to implement the present invention. 
     Exhibit A provides data structures for messages and codewords and routines to encrypt messages into codewords and to decrypt encrypted codewords back to messages. It also provides routines for encoding and decoding with no encryption. The decoding algorithm used can correct up to S errors per codeword were S is the degree of the Goppa Polynomial. 
     Details of the algorithms used are documented in each of the following package bodies and their subunits. &#34;Generic package Goppa --  S --  Crypt&#34; This package implements the Public Key Encryption Algorithm using the Goppa Error Correcting Code. The &#34;Public Key&#34; is a transformation of the Goppa Code Generator matrix that can be used to generate codewords in the code. This transformation G&#39; is obtained by the matrix multiplications G&#39;=SGP. However, knowledge of the public key does not enable one to decode the generated codewords without knowledge of the original generator matrix and/or the S and P matrices, all of which are kept secret. Thus even stations that encrypt cannot decrypt without the secret key, and the public key can be freely distributed without loss of security to the system. 
     In operation this package, and generic packages Generator, Goppa --  Syndrome, Finite --  Field --  Euclids, and Square --  Root --  Mod --  Goppa are instantiated, and the following constants, types and functions are provided: 
     A natural constant Degree --  Of --  Goppa --  Poly that holds the degree of the Goppa polynomial. 
     An instantiation of the Generator package, which provides a Generator Matrix, a Parity Check Matrix, a Column Restored Generator Matrix whose columns have been restored to proper positions for decoding of codewords generated from this matrix. Also provided is the length of messages for the code, Information --  Length. 
     A subtype Message that represents binary messages. 
     A subtype Codeword that represents binary words of the code. 
     A function Encode that accepts a Message and returns the Codeword for that message. The codeword is by default ready for decoding, i.e., bit positions are arranged for the decoder and may not be in systematic form. The user may choose to get the codeword in systematic form, but in a form where the decoder may fail by setting the optional parameter Fix --  Cols to False. 
     A function DECODE that accepts a Codeword with an unknown number of errors, and returns a corrected codeword in the Goppa Code. If more than S errors are present, the decoding will fail and exception Exceeded --  Error --  Correction --  Cap will be raised. If the optional debug parameter is set to true, the vectors and polynomials obtained during the calculations are printed to the standard output, and exceptions raised by decoder failure are noted and handled locally. 
     A function Systematic --  Form that accepts a codeword (that may or may not contain errors) and converts it to systematic form, i.e., the information bits are isolated in one part of the codeword. The information bits will be in positions Codeword --  Length - Information --  Length, i.e., the last Information --  Length bits. This function is included for use in interactive experimentation. It should not be used as part of the decoding process, since function Recover --  Message will extract the information bits from a codeword in a more efficient manner. 
     A function Recover --  Message that accepts a Codeword that has not been put in systematic form and returns a Message containing the information bits of the codeword in their proper order. This function is intended to be used after decoding a codeword. 
     A function Encrypt that accepts a binary message and returns a codeword encrypted via the public key. The optional parameter Debug toggles the debugging mode. 
     A function Decrypt that accepts an encrypted binary codeword and returns the original unencrypted message. The optional parameter debug toggles the debugging mode. Note that the Decrypt function must accept binary vectors created by the Encrypt function. Unencrypted binary vectors produced by the Encode function will not be correctly decoded here. 
     An exception Exceeded --  Error --  Correction --  Cap that is raised when the decoder fails to decode an input codeword. This may occur when there are more that S errors in the input, or when some unexpected internal error occurs. 
     The instantiation of the package requires the following inputs 
     Finite Field Inputs, a private type coefficient that will provide a data structure to represent the coefficients of each term of the polynomial (i.e., a finite field element). Polynomials will also evaluate to objects of this type. Coefficients must be Field --  Elements from the instantiation of package Finite --  Field. 
     A natural Coeff --  Binary --  Form --  Length that is the length of a coefficient&#39;s binary representation. A coefficient that does not have such a form cannot be used to create a generator matrix and thus cannot be used to instantiate this package. 
     The zero of the finite field of coefficients, Zero --  Coeff. 
     The unit of the finite field of coefficients, Unit --  Coeff. 
     A function Get --  Coeff 13  Binary --  Form that accepts a coefficient and returns that coefficient&#39;s binary form of type Binary --  Polynomials --  Poly. 
     A function Invert --  Coeff that accepts a coefficient and returns its inverse in the finite field. 
     A function Add --  Coeffs that accepts two coefficients and returns their field arithmetic sum as a coefficient. 
     A function Multiply --  Coeffs that accepts two coefficients and returns their field arithmetic product as a coefficient. 
     A function Alpha --  To --  Power that accepts a natural number representing the desired power of field primitive alpha and returns the corresponding coefficient. 
     A function Coeff --  To --  Power that accepts a coefficient (field element) and a natural power and returns the coefficient exponentiated to that power as a coefficient (element in the finite field). 
     A function SQRT --  Of --  Coeff that accepts a coefficient and returns its square root in the finite field. 
     A procedure Print --  Coeff that prints a field element to the standard output. Used to print out the matrix. Polynomial Inputs 
     A range Degreetype that provides the range of valid degrees of terms of polynomials of type Polytype. 
     A private type Polytype that will provide a data structure for polynomials. Polytype must be of type Poly from the instantiation of package General --  Polynomials. Coefficients of these polynomials are field elements from Finite --  Field. 
     The Zero --  Poly, the polynomial of degree zero whose coefficient is the zero coefficient. 
     The Unit --  Poly, the polynomial of degree zero whose coefficient is the unit coefficient. 
     A function Evaluate --  Poly that accepts a polynomial and a coefficient, and returns the value of the polynomial when evaluated at that coefficient. The result is returned as type coefficient. 
     A function of Build --  Poly that accepts a polynomial, a natural number indicating a term in that polynomial, and the new coefficient to be inserted at that term. Returns the input polynomial with the new coefficient at the desired term. 
     A function Add --  Polys that accepts two polynomials and returns their sum. 
     A function Subtract --  Polys that accepts two polynomials and returns their difference. 
     A function Multiply --  Polys that accepts two polynomials and returns their product. 
     A procedure Divide --  Polys that accepts two polynomials and returns (via &#34;out&#34; parameters) their quotient and remainder. 
     A function Degree --  Of --  Poly that accepts a polynomial and returns its degree as type Degreetype. 
     A function &#34;&lt;&#34; that compares two polynomials and returns True if the left polynomial is less than the right polynomial and returns False otherwise. 
     A function Coeff --  Of --  Poly that accepts a polynomial and a degree of a polynomial term of type Natural, and returns the coefficient of the polynomial term at the specified degree. 
     A procedure Print --  Poly that prints a polynomial of type Polytype to the standard output file. 
     A polynomial Goppa --  Poly of type polytype that represents the Goppa Polynomial for this code. 
     Other Inputs 
     A constant Codeword --  Length that specifies the length of codewords for this code. 
     A function Make --  Matrix that accepts a value Matrix --  Size of type natural and returns a &#34;scrambled&#34; binary matrix to be used for the encryption/decryption process. This matrix must be invertible or the algorithm will fail and the user supplying this function is responsible for this. A boolean parameter Col --  Permute --  Only specifies when true that the scrambled matrix is to be a permutation matrix only (i.e., has 1 nonzero entry in each row and col) and does not have any row or col additions performed. 
     A function Random --  Natural that accepts a natural number upper limit and returns a &#34;random&#34; value between zero and the specified limit. The returned value is of type Natural. 
     To provide these inputs a series of other packages are provided which define and provide means for operating (i.e., build, initiate, evaluate, exponent, square root, inverse, add, subtract, multiply and divide) on polynomials and finite fields. These packages include binary --  polynomials, which adds and defines the weight thereof; General Polynomials, which builds initials, obtains the Coeff and, obtaining the degree, evaluates (&#34;&lt;&#34;); adds, subtracts, multiplies and divides the polynomials; Finite Field which provides for definition both in log form and polynomial form, and which provides for evaluation of (&#34;&lt;&#34;), addition, subtraction, multiplication, division, square root exponential and inverse functions; and a Binary Matrices and Field Matrices packages, which perform certain operations including: RRE form, transposition, concatenation, identification, addition, multiplication, vector multiplication and finding the inverse of the matrice. The source code listing for each of these program packages is also attached hereto as Exhibit A. 
     FIG. 4, illustrates in function block form, the application of the Goppa Decoding Algorithm, illustrated at 23 in FIG. 3. As illustrated in FIG. 4, the input to the Goppa Decoding Algorithm is mSG combined with the error vector (e)P -1 . The first step is the calculation of the Goppa Syndrome S(x) modGx, which is carried out by package SYND, an instantiation of generic package Goppa-Syndrome, which computes the syndrome S of a received vector R for a Goppa code via the algorithm. 
     
         S(x)=SUM(i=0 to .sub.n-1) [R(i)*(1/x-alpha(i))] mod G(x) 
    
     where G(x) is the Goppa Polynomial. 
     If S(x)=0 then no error vector is present and the remaining operations in FIG. 4 are terminated. As illustrated at 28, 29 since given mSG, with no errors present, mS may be recovered from mSG with a simple vector selection, without recourse to the remainder of the Goppa Decoding Algorithm. 
     The inverse of the syndrome is calculated, illustrated at 30 of FIG. 4, using, the subunit Invert-Poly. If only the zero location is in error, the first bit is flipped as indicated at 31, 32 and remainder of the Goppa Decoding Algorithm is omitted, since no errors remain, and mS may be recovered from mSG without recourse to the remainder of the Goppa Decoding Algorithm. 
     The next step, illustrated at 33 in FIG. 4 is to calculate the square root of T(x) +x, stopping when the degree of the remainder is less or equal to the floor of S/2, using the Goppa-Sqrt package, an instantiation of the Square --  Root --  Mod --  Goppa package, yielding polynomial R(x). 
     Euclid&#39;s Algorithm is then performed on R(x) and the Goppa Polynomial using the FF-Euclids package, an instantiation of the Finite --  Field --  Euclids package as illustrated at 34, and sigma is computed from alpha and beta wherein σ=σ 2  +x (β 2 ). 
     The roots of sigma are then found in the finite field, and identified as the error locations. If there are no roots for an input word with a non-zero syndrome, then an uncorrectable error has occurred. If there are more than S, degree of G, roots, an uncorrectable error has occurred. Each of these errors raises an exception, Exceeded --  Error --  Correction --  Cap. The error locations in the error vector are then set to &#34;1&#34;, and the error vector is added to the input word to get the corrected word. 
     If appropriate, the recovered error vector may also be passed to the secondary recovery channel for recovery of the secondary message or authenticate code as illustrated at 27 in FIG. 3. However, the error vector recovered at step 36 in FIG. 4 is not the same as the intentional error vector added at step 18 of FIG. 2, since the received vector was multiplied by the inverse of the permutation matrix p to form rP -1  and therefore eP -1  in step 22 of FIG. 3. It is therefore necessary to multiply the recovered error vector eP -1  by the permutation matrix to obtain (e) the original intentional error vector. ##EQU4## 
     The preceding description is quite compact and a full treatment of the Goppa Decoding Algorithm may be found in Chapter 8 of The Theory of Information and Coding, Vol 3  of The Encyclopedia of Mathematics and Its Applications published by Addison Wesley, Reading, Mass. 1977, the text and teachings of which are incorporated herein by reference thereto. 
     In summation, the essential elements of the present invention are as follows: 
     the t error correcting code generator matrix is `scrambled` to produce an equivalent code which appears not to possess a fast decoding algorithm. 
     the scrambled generator matrix is made public. 
     anyone who wishes to correspond with the originator of the system encodes using the public generator matrix and standard matrix multiplication. 
     an error vector with at most t ones is intentionally added to the codeword to corrupt the encoded message and (a) additionally correct a limited number of communication channel errors in the case where the weight of e is less than t or (b) or carry a secondary message, such as an authentication code. 
     the receiver is able to unscramble the effect of the public generator matrix and rapidly decode. 
     anyone without the ability to unscramble the public generator matrix will be forced to use a hopelessly complex and time consuming general decoding method for binary linear codes. 
     FIG. 5 is a paradigm which illustrates and summarizes the sequence of events described above in which matrix multiplication is used as part of the encryption process, and the inverses of S and P are used in the decrypting process which ultimately recovers the message m. 
     The present invention takes advantage of the inherent error correcting capability of linear codes to perform two (2) functions. The encryption algorithm is capable of performing correction of channel induced errors, as well as simultaneous data encryption. Suppose that t=x+y is the error correction capability of the code where x, y are positive integers. Suppose further that in the encryption portion of the process, the sender uses an error vector with only x ones. Then as many as y additional errors may be inserted by the communication channel and still not exceed the error correction capability of the code. Thus, this approach permits simultaneous encryption for secrecy and encoding for error control. It is a property possessed by no other public key encryption process. 
     In order to solve some channel problems, a surprisingly small number of ones may be required. Consider the following situation. Many common carrier high speed data channels have a minimum requirement for &#34;ones density&#34;. If too many consecutive zeros are transmitted, the receiver will begin to misframe databits and problems result. On most communication links, encryption devices, to the extent that they are destroyers of order and information, frequently simulate the behavior of random number generators. Occasionally, strings of zeros which are too long may be output by the encryption process. This error control based encryption process, however, handles the problem easily. Instead of using an error vector with t ones to corrupt data, use an error vector with t-1 ones. Set up a counter to count consecutive zeros, and if a too long string of zeros begins to develop, arbitrarily change a zero to a one. Since the number of errors in any given code word will still not exceed t, the communication process continues smoothly. 
     MATHEMATICAL STRUCTURE 
     The following section sets forth the formal definition of the desired, but restricted class of Goppa codes and derives certain basic results necessary to support the previously discussed cryptographic algorithm. A numerical example is also provided. For the purposes of the following examples, it is assumed that one skilled in the art is familiar with polynomial operations over a finite field. 
     Let a 0 , a 1 , a 2 , ..., a n-1  be an ordering of the n=2 m  elements of GF(2 m ). Let G(x) be an irreducible polynomial over GF(2 m )) and let v=(v 0 , v 1 , v 2 .., v n-1 ) be a binary n-tuple. With this binary n-tuple, associate the following rational form ##EQU5## 
     First, define V to be set of all binary n-tuples, v, such that ##EQU6## Note that (0,0,0, ..., 0) εV, so that V is not empty. 
     Theorem: V is a linear code. 
     Proof: Suppose u,v εV. Then ##EQU7## and ##EQU8## which implies that ##EQU9## so that (u+v)εV. 
     Since V is a closed subset of the set of all binary n-tuples, it is a luinear code. Q.E.D. 
     V is the Goppa code used in the encryption system of the present invention. It should be noted that the Goppa codes of the present invention are defined using only irreducible polynomials, G(x), and thus constitute a restricted class of such codes. 
     Theorem: If G(x) is irreducible and deg G(x)=s≧2, then the associated Goppa code, V, has minimum distance d min  ≧2s+1. 
     Proof: Let v=(v 0 , v 1 , . . . , V n-1 ) ΕV be a non-zero code word. Then ##EQU10## where v i   1 , v i   2 , . . . , V i   k  are the non-zero components of v. 
     Define ##EQU11## and take the formal derivative of f(x): ##EQU12## Then: ##EQU13## and ##EQU14## 
     But this implies that G(x) divides f&#39;(x). Now f&#39;(x) contains only even powers of x, since the field has characteristic 2. 
     Thus ##EQU15## 
     We claim that G(x) also divides g(x). Suppose it does not. Then ##EQU16## 
     This implies that 
     
         a(x)g.sup.2 (x)+b(x)G(x)g(x) =g(x) 
    
     but this is a contradiction. Thus G(x) divides g(x). But if G(x) divides g(x) and f&#39;(x) =g 2  (x), then 
     
         G.sup.2 (x) divides f&#39;(x). 
    
     But ##EQU17## 
     Now it is noted that ##EQU18## 
     Therefore 2degG(x)+1≦d min . Q.E.D. 
     In accordance with the present invention an efficient decoding algorithm for these Goppa codes may be constructed as follows: 
     Let v be the binary code word transmitted through a noisy channel, and let 
     
         r=v+e 
    
     be the received word, where 
     v=binary n-tuple code word, 
     r=received word, 
     e=error vector of weight =s,s=degG(x), 
     and addition is modulo 2. 
     Next define the syndrome for the above received word, r, to be ##EQU19## since v is a code word and ##EQU20## 
     Now e=(e 0 , e 1 , . . . , e n-1 ) is an error vector of weight at most s. Suppose the s non-zero components of e correspond 
     
         a.sub.i.sub.1, a.sub.i.sub.2, a.sub.i.sub.3, . . . , a.sub.i.sub.5 
    
     Next we define the error locator polynomial, ##EQU21## 
     Then calculate the formal derivative ##EQU22## 
     But now we may write ##EQU23## 
     Now ##EQU24## has degree s. It is composed of both even and odd powers of x. 
     Thus it may be written, ##EQU25## where ##EQU26## 
     In this case, σ&#39;(x)=β 2  (x). 
     Next, it is necessary to find α(x) and β(x), and thus the roots of σ(x). To begin this process, one next determines the inverse of S(x), assuming that S(x)≠0. 
     Since 
     
         deg S(x)≦s-1, and G(x) is irreducible g.c.d. (S(x), G(x))=1 
    
     and there exist T(x) and U(x) such that 
     
         T(x)S(x)+U(x)G(x)=1 
    
     or equivalently 
     
         T(x)S(x)□1modG(x). 
    
     If it is required that degT(x)&lt;degG(x) and degU(x)&lt;degS(x), then T(x) and U(x) are unique. 
     Next 
     
         a(x)S(x)□σ&#39;(x)modG(x) implies that 
    
     a(x)S(x)T(x)□σ&#39;(x)T(x)mod G(x) 
     which upon substitution implies 
     
         a.sup.2 (x)+x β.sup.2 (x)≡β.sup.2 (x)T(x) mod G(x) 
    
     and 
     
         [T(x)+x]β.sup.2 (x)≡a.sup.2 (x)mod G(x) 
    
     It is then necessary to consider two cases: T(x)=x, T(x)≠x. 
     Case 1) T(x)=x. Then σ(x)=x and we have a solution to S(x)σ(x)≡σ&#39;(x) mod G(x). 
     Case 2) T(x)=x. This is the more interesting and general case. In what follows, assume that T(x)≠x. 
     By choosing the correct value of the intentional error vector to possess more than one (1) error, it is possible to disregard Case 1, and go directly to Case 2. 
     There is a unique polynomial R(x) such that 
     
         R.sup.2 (x)≡T(x)+x mod G(x) 
    
     Consider the set of all polynomials of degree less than the degree of G(x), {P 1  (x), P 2  (x), . . .}. 
     Since G(x) is irreducible, they constitute a field. Consider the &#34;squares&#34; of all such polynomials, again reduced modulo G(x), {P 2   1  (x), P 2   2  (x), . . . }. 
     Clearly {P 1  (x), P 2  (x), . . . }={P 2   1  (x), P 2   2  (x), . . . }, and every element has a unique square root. 
     Thus, every element of degree less than s, including T(x)+x, can be represented as the square of a unique polynomial. 
     
         Let R.sup.2 (x)≡T(x)+x mod G(x). 
    
     But this implies that 
     
         β.sup.2 (x)R.sup.2 (x)≡a.sup.2 (x) mod G(x) 
    
     and 
     
         β(x)R(x)≡a(x) mod G(x). 
    
     In order to determine o(x)=σ 2  (x)+β 2  (x) we require an efficient procedure for finding σ (x) and β (x) given R(x) and G(x). For this the Euclidean algorithm is used. 
     Given two polynomials, such as G(x) and R(x), with deg G(x)≧deg R(x), repeated divisions are made: ##EQU27## The following recurrence relations may now be defined: ##EQU28## With the following initial conditions ##EQU29## It is noted that several properties are associated with these recurence relations. ##EQU30## Finally the following important lemma may be proved. 
     Lemma 4 With G(x),R(x) defined as above, there exists a unique integer i,0≦i≦n such that ##EQU31## 
     Proof 
     Recall that both deg r j  (x) and deg t j  (x) are strictly decreasing and increasing sequences, respectively. One may define i by requiring that 
     
         deg r.sub.i-1 (x)≦s/2+1 
    
     
         deg r.sub.i (x)≦s/2. 
    
     There can be only one such value for i. Then, by Lennna 3 
     
         deg t.sub.i (x)+deg r.sub.i-1 (x)=deg G(x0=s, 
    
     which implies that 
     
         deg t.sub.i (x)≦s. s/2-1 
    
     
         deg t.sub.i+1 ≦s. s/2. 
    
     Again, there can be only one such value for i. Q.E.D. 
     With the forgoing one may now prove the most important result. 
     Theorem 
     Given the equivalence relation ##EQU32## there is a unique i such that 
     
         β(x)=t.sub.i (x) 
    
     
         α(x)=r.sub.i (x). 
    
     Proof 
     One separates the proof into two parts. (Part 1) Suppose that one assumes, for the moment, that ##EQU33## 
     It may be shown that i is unique. 
     Re-write the restrictions on the degrees of the polynomials α (x) and β (x) using the greatest integer functions: ##EQU34## But ##EQU35## so that ##EQU36## and it is seen that 
     
         deg α(x)≦ s/2 ps 
    
     
         deg β(x)≦x- s/2 -1, 
    
     the upper bounds from Lemma 4. 
     Thus, on the assumption that some index i exists such that 
     
         β(x)=t.sub.i (x) 
    
     
         α(x)=r.sub.i (x), the index is unique 
    
     since 
     
         deg β(x)=degt.sub.i (x)≦s- s/2 -1 
    
     
         deg α(x)=degr.sub.i (x)≦ s/2 . 
    
     (Part 2) Using Lemma 2 and β(x)R(x) - α(x) modG(x) one may write the following equations ##EQU37## Multiplying by β (x) and t i  (x) respectively one obtains ##EQU38## But this implies that 
     
         β(x)s.sub.i (x)G(x).t.sub.i (x)s(x)G(x)=β(x)r.sub.i (x).t.sub.i (x)α(x) 
    
     or, equivalently 
     
         β(x)r.sub.i (x)≡t.sub.i (x)α(x) modG(x). 
    
     Examining the degrees of both sides of this equivalence shows 
     
         degβ(x)+deg r.sub.i (x)≦ s-1+ s/2 &lt;s 
    
     
         deg t.sub.i (x)+degα(x)≦s- 2 1+ s2°&lt;s, 
    
     so the equivalence is an equality: 
     
         β(x)r.sub.i (x)=t.sub.i (x)α(x). 
    
     Substituting back into the same pair of equations (2) we see that this implies 
     
         β(x)s.sub.i (x)G(x)=t.sub.i (x)s(x)G(x) 
    
     and finally 
     
         β(x)s.sub.i (x)=t.sub.i (x)s(x). 
    
     Now from Lemma 1 it is known that g.c.d.(s i  (x),t i  (x))=1 which implies that 
     
         s(x)=λ(x)s.sub.i (x) 
    
     
         β(x)=λ(x)t.sub.i (x) for some λ(x). 
    
     Substituting into the original pair of equations (1) we have 
     
         s.sub.i (x)G(x)+t.sub.i (x)R(x)=r.sub.i (x) 
    
     
         λ(x)s.sub.i (x)G(x)+λ(x)t.sub.i (x)R(x)=α(x). 
    
     Multiplying the top equation by λ(x) and comparing it may be seen 
     
         α(x)=λ(x)r.sub.i (x). 
    
     Thus, it may be finally shown that 
     
         β(x)=λ(x)t.sub.i (x) 
    
     
         α(x)=λ(x)r.sub.i (x) for some λ(x). 
    
     Recall that σ(x) is the Goppa code error locator polynomial, and ##EQU39## after substitution. 
     But, by its construction, σ (x) has only simple zeros. Thus λ(x) is a constant, which may taken to be 1 for ease of computation. Q.E.D. 
     In summary, to decode, one performs the following steps: 
     1. Compute the syndrome, S(x). 
     2. Compute T(x) such that T(x)S(x)≡1 mod G(x). 
     if T(x)=x, we are finished. 
     if T(x)≠x, continue. 
     3. Compute R(x) such that R 2  (x)≡T(x)+xmodG(x). 
     4. Solve β(x)R(x)≡σ (x)modG(x) using Euclid&#39;s algorithm. Stop when 
     
         deg r.sub.i (x)≦ s/2 
    
     
         deg r.sub.i-1 (x)≦ s/2 +1 
    
      and set 
     
         α(x)=r.sub.i (x) 
    
     
         β(x)=t.sub.i (x). 
    
     Find the roots of 
     σ(x)=σ 2  (x)+x β 2  (x). 
     EXAMPLE 1 
     In order to give a concrete demonstration of the encryption and decryption processes, consider the following example. 
     Let G(x)=x 2  +x+1 be the irreducible Goppa polynomial over GF(2 3 ), where the ordering of the field elements is given by 
     
         O, σ.sup.0, σ.sup.1, σ.sup.2, σ.sup.3, σ.sup.4, σ.sup.5, σ.sup.6 
    
     and σ is a root of the primitive polynomial x 3  +x+1. The Goppa code defined by these conditions has n=8, t=2 and k=2. There are only four code words. 
     It can be shown that a generator matrix for this code is given by ##EQU40## 
     Next, this matrix is scrambled by forming 
     G&#39;=SGP, where S is nonsingular and P is a permutation matrix. 
     The following matrices are: ##EQU41## From among the four possible message 2-tuples, choose m=(10) and form the code word 
     
         mG&#39;=(10110011)=v. 
    
     Since the code is capable of correcting up to 2 errors, select an error vector of weight 2. Let ##EQU42## Suppose that r is now transmitted through a channel and that no additional channel errors are inserted At the receiving end, one begins the decrypting process by applying p -1 . 
     Form rP -1  =(10010100), and then begin the Goppa decoding procedure. 
     Then form the syndrome ##EQU43## Find T(x) such that 
     
         T(x)S(x)≡1 mod x.sup.2 +x+1. 
    
     It can be seen that 
     
         T(x)≡a.sup.5 x+a.sup.0 ≡a.sup.5 x+1. 
    
     Next, find R(x) such that 
     
         R.sup.2 (x)≡T(x)+x≡a.sup.4 x+1mod x.sup.2 +x+1. 
    
     It can be seen that 
     
         R(x)≡a.sup.2 x+a.sup.6. 
    
     Next, solve for α (x) and β (x) in the congruence relation 
     
         β(x)(a.sup.2 x+a.sup.6)≡a(x) mod x.sup.2 +x03 1. 
    
     Which finds that ##EQU44## 
     The roots of σ (x) are seen to be: 
     
         x=α.sup.0 
    
     
         x=α.sup.1 
    
     Thus ##EQU45## which is the corrected codeword. 
     But then it is straightforward to verify that 
     
         mS=(10) 
    
     and thus, 
     
         m=mss.sup.-1 =(10), 
    
     the original message vector. 
     A natural by-product of the decoding process is the permuted error vector 
     
         e&#39;=(01100000). 
    
     The original error vector may be obtained by forming the product 
     
         e&#39;P=e=(10010000). 
    
     Thus, it is clear that the original error vector itself is recoverable and can be used as a carrier of information.