Okamoto Uchiyama cryptosystem

from Wikipedia, the free encyclopedia

The Okamoto-Uchiyama cryptosystem is a semantically secure , asymmetric encryption algorithm . It was first presented in 1998 by Tatsuaki Okamoto and Shigenori Uchiyama at Eurocrypt , one of the largest annual cryptography conferences . The method is additive-homomorphic, which means that the plain texts are added by multiplying two key texts. It is therefore not necessary to decrypt the key texts in order to be able to operate on the plain texts.

Procedure

Like many asymmetric encryption methods, the Okamoto-Uchiyama cryptosystem works in a group . However, in contrast to other methods, e.g. B. RSA , of the form where are large prime numbers . The method is homomorphic and therefore suffers from the problems it entails.

Generation of the public and private key

The key pair is generated as follows:

  • You generate two prime numbers of the same bit length and set . In practice, it should have at least 1024, but better 1536 or 2048 binary digits .
  • One randomly chooses in so that there is order .
  • One defines

The public key consists of , the private key consists of .

Encrypt messages

To encrypt a message with , proceed as follows:

  • First you choose a random one .
  • The encrypted message is then given through .

Decrypting messages (decoding)

To decrypt, you first define the function . Then the original message is obtained as follows:

  • One defines .
  • One sets .

In the last step it should be noted that the division must be carried out modulo , i. i.e., by multiplying by the multiplicative inverse . The division in the calculation of is carried out over the whole numbers.

Correctness of the Okamoto-Uchiyama cryptosystem

For an odd prime number , the p-group of is defined as

.

That is, contains exactly those elements of which yield 1 when divided by the remainder.

One then defines the logarithmic function on the elements of as

.

This value is always an integer, since it applies to all that .

The task now is: .

Proof :

The first equation is true because of . The last equation holds because after the above observation holds.

If it holds for one that , and furthermore is for one , one also obtains

.

This is the reason for the name logarithmic function , since the discrete logarithm of in basis is calculated.

Proof : This follows trivially from the previous property, because and holds.

The overall correctness of the procedure follows from this, that is

actually matches the original message .

Proof : We observe first that

,

where Lagrange's theorem was used for the last equation . We then get:

.

It is important here that , and therefore also , was fulfilled, since the prerequisite was a number with a length of k bits.

safety

Under the p subgroup assumption, it can be shown that the method is semantically secure . Inverting the encryption has been proven to be just as complex as factoring the module .

Homomorphism properties

As with all homomorphic encryption methods, an attacker can change a ciphertext in such a way that it is decrypted into a plaintext that is related to the original plaintext. For example, be the encryption of an unknown value . Then, by multiplying with the encrypted value, it can be changed very easily by any value :

.

In a similar way, you can also multiply the unknown plaintext by any factor by exponentiating the ciphertext:

.

However, in order to achieve a reasonable result here (e.g. a doubling of the plain text), it must be guaranteed that the following applies, or even so that the recipient cannot draw any conclusions about the manipulation from the decryption (all correctly encrypted plain texts are allowed according to the regulations it should be bits long at most).

advantages

The homomorphic properties are u. a. exploited in connection with the following applications.

  • E-voting : After each eligible voter has encrypted their vote (in the simplest case a 1 for yes , a 0 for no ) and transmitted it to the electoral authority, all key texts are multiplied and the resulting encryption contains the encryption of the total number of yes votes. The result of the election is obtained by decoding. It is important that the party performing the first step does not need to know the secret key, which means that no individual votes can be decrypted.
  • eCash
  • Zero-knowledge evidence in the Universal Composability Model

disadvantage

Due to the listed homomorphic properties, however, the method is not IND-CCA safe, i. H. not safe under selected ciphertext attacks . Every encryption system that has this security would have to be non-deformable , a property that contradicts homomorphism. In the literature one also finds transformations to transform the system into an IND-CCA safe variant. Whether these transformations are appropriate or not depends on the particular application.

Complete example

The steps outlined above are illustrated here using a small example.

Key generation

First, two secret prime numbers are chosen, for example and . Both have 10 bits in binary representation, i.e. h., it is . This also results in:

The random, appropriate choice of supplies

  • , where and applies.

The public key is given by:

The secret key is .

Preliminary work

In a first step, the text to be encrypted must be translated into numbers smaller than the number . To do this, we simply replace each letter with its position in the alphabet:

A=01 B=02 C=03 usw. (00 = Leerzeichen)

We now encrypt each character individually, since two consecutive letters u. U. could deliver too great a value.

Klartext:  O  U  K
Kodierung: 15 21 11

Encryption

We have three plaintexts to encrypt ( , and ), for each of which we need one.

r1 = 523.423.432
r2 =  43.412.311
r3 = 633.186.663

The encryptions thus result in:

ci = gmihri mod n
c1 = 33270615 344141213523423432 mod 916872763 = 289652071
c2 = 423840839
c3 = 684226192

Decryption

We can decipher the messages by:

mi = L(cip-1 mod p2) / L(gp) mod p

It is important here that the division is carried out. We therefore calculate the multiplicative inverse of modulo using the extended Euclidean algorithm and thus obtain . This results in the decryption to:

m1 = L(2896520711018 mod 1038361) * 502 mod 1019 = 15
m2 = 21
m3 = 11

By inverting the substitution rule , these values ​​can now be translated back into letters.

swell

  1. Tatsuako Okamoto and Shigenori Uchiyama: A new public-key cryptosystem as secure as factoring (English) . In: Eurocrypt 98 , Springer Verlag, 1998, pp. 308-318.  ( Page no longer available , search in web archives ) @1@ 2Template: Dead Link / link.springer.com
  2. Eiichiro Fujisaki and Tatsuako Okamoto: How to Enhance the Security of Public-Key Encryption at Minimum Cost (English) . In: PKC 99 , Springer Verlag, 1999, pp. 53-68.  ( Page no longer available , search in web archives ) @1@ 2Template: Dead Link / link.springer.com
  3. Pascal Paillier and David Pointcheval: Efficient Public-Key Cryptosystems provably Secure Against Active Adversaries (English) . In: ASIACRYPT 99 , Springer Verlag, 1999, pp. 165-179.  ( Page no longer available , search in web archives ) @1@ 2Template: Dead Link / link.springer.com