我编写了一个用于 RSA 加密和解密的 Java 代码，其中解密密钥太大，因此解密过程需要永远执行

Question

I have to use p=78511 and q= 5657 as per my requirement of the program, the code executes without errors but I as the value of dec_key is too large, it does not display the decrypted text, keeps on running. How do I solve this? Is there a way to have smaller dec_key or am I doing the decryption method all wrong. Here I am trying to pass a character "H" in the encryption method for now. Attaching the code. Please do not block my question. I am new here and not so sure how to ask questions, just let me know where I am wrong. Thanks!

package crypto.assgn4;  
import static crypto.assgn4.Problem2.phi;
import java.math.BigInteger;
class Test {

static char[] characters = {' ', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
static BigInteger p = BigInteger.valueOf(78511);
static BigInteger q = BigInteger.valueOf(5657);
static BigInteger N = p.multiply(q);
static BigInteger phi = (p.subtract(BigInteger.ONE)).multiply(q.subtract(BigInteger.ONE));
static BigInteger e = BigInteger.ZERO, d;

public static void main(String args[]) {

    e = new BigInteger("4");
    while ((gcd(phi, e).intValue()>1)) {
        e = e.add(new BigInteger("1"));
    }

    d = BigInteger.valueOf(mul_inverse(e, phi));
    if (d.equals(e)) {
        d.add(phi);
    }

    System.out.println("Encryption Key : "+e);
    System.out.println("Decryption Key : "+d);

    String c = encrypt("H",e,N);
    String p = decrypt(c,d,N);

    System.out.println("Cipher : "+c);
    System.out.println("Text : " +p);


}

public static BigInteger gcd(BigInteger a, BigInteger b) {
    while (b != BigInteger.ZERO) {
        BigInteger temp = b;
        b = a.mod(b);
        a = temp;
    }
    return a;
}


public static int mul_inverse(BigInteger number, BigInteger sizeOfAlphabet) {
    int a = number.intValue() % sizeOfAlphabet.intValue();
    for (int x = 1; x < sizeOfAlphabet.intValue(); x++) {
        if ((a * x) % sizeOfAlphabet.intValue() == 1) {
            return getMod(x, sizeOfAlphabet.intValue());
        }
    }
    return -1;
}


public static int getMod(int x, int y) {
    int result = x % y;
    if (result < 0) {
        result += y;
    }
    return result;
}

/**
 * ********************************************************************************
 */
static String encrypt(String plainText, BigInteger e, BigInteger N) {
    StringBuilder cipherText = new StringBuilder();

    for (int i = 0; i < plainText.length(); i++) {
        int index = plainText.charAt(i);
        cipherText.append("").append((char) (new BigInteger(index + "").pow(e.intValue()).mod(N).intValue()));
        char c1 = (char) (new BigInteger(index + "").intValue());
    }
    return cipherText.toString();
}

static String decrypt(String cipherText, BigInteger d, BigInteger N) {

    String plainText = "";
    for (int i = 0; i < cipherText.length(); i++) {
        int index = cipherText.charAt(i);
        plainText += "" + (char) (new BigInteger(index + "").pow(d.intValue()).mod(N).intValue());

    }
    return plainText;
}

}

Answer 1

It looks like you are doing the encryption/decryption all wrong.

The point of RSA is to take the entire bit pattern of the encoding of the String, and treat that as if it were a BigNumber (eg BigInteger) in its own right. (Note : if that BigNumber is > the modulo then the string has to be chunked in portions such that the BigNumber becomes < the modulo.)

What you are doing on a character by character basis is unnecessary overkill, probably plain wrong as well and obviously the source of long running times. (Encrypting your single-character string might still go well because even on a character-by-character basis you'll do only one encryption. But it will yield a string of length x and then the decryption will do x BigInteger computations and that will inevitably take longer.)