Лабораторная работа 31 / RSACrypt

import java.math.BigInteger;
import java.util.Date;
import java.util.Random;

/**
 * <p>Title: RSA keys generation, encryption / decryption routines</p>
 *
 * <p>Description: class provides functionality for generating private and
 * public keys of the given length, encryption and decryption of messages
 * using generated keys</p>
 *
 * @author Vladimir Kaparkov
 * @version 1.0
 * @since 1.5
 */
public class RSACrypt {
    private BigInteger p;
    private BigInteger q;
    /**
     * Common key part
     */
    private BigInteger m;
    private BigInteger mBackup = BigInteger.ZERO;
    /**
     * Public key
     */
    private BigInteger e;
    private BigInteger eBackup = BigInteger.ZERO;
    /**
     * Private key
     */
    private BigInteger d;
    private BigInteger dBackup = BigInteger.ZERO;
    /**
     * Length of the key in bits
     */
    private int keyLength = 512;
    /**
     * Generate keys
     */
    private void calculateParams() {
        p = BigInteger.probablePrime(keyLength/2, new Random(new Date().getTime()));
        q = p.nextProbablePrime();
        m = p.multiply(q);
        BigInteger phi = p.subtract(BigInteger.ONE).
                         multiply(q.subtract(BigInteger.ONE));
        int startLen = keyLength*3/4;
        e = BigInteger.probablePrime(startLen, new Random(new Date().getTime()));
        while (phi.gcd(e).compareTo(BigInteger.ONE) != 0)
            e = BigInteger.probablePrime(++startLen, new Random(new Date().getTime()));
        BigInteger[] curDivRem = new BigInteger[2];
        //BigInteger Pim2 = BigInteger.ZERO;
        //BigInteger Pim1 = BigInteger.ONE;
        BigInteger Qim2 = BigInteger.ONE;
        BigInteger Qim1 = BigInteger.ZERO;
        BigInteger curDiv = phi;
        BigInteger curVal = e;
        curDivRem = curVal.divideAndRemainder(curDiv);
        int k = 0;
        while (curDivRem[1].compareTo(BigInteger.ZERO) != 0) {
            BigInteger Q = curDivRem[0].multiply(Qim1).add(Qim2);
            Qim2 = Qim1;
            Qim1 = Q;
            //BigInteger P = curDivRem[0].multiply(Pim1).add(Pim2);
            //Pim2 = Pim1;
            //Pim1 = P;
            curVal = curDiv;
            curDiv = curDivRem[1];
            curDivRem = curVal.divideAndRemainder(curDiv);
            k++;
        }
        d = ((k-1)%2==1) ? Qim1.negate() : Qim1;
    }

    public RSACrypt() {
        calculateParams();
    }

    /**
     * Generate new keys
     */
    public void regenerateKeys() {
        calculateParams();
    }

    /**
     * Set private key to the given value. No checks are perfomed
     * @param key BigInteger value to set private key to
     */
    public void setPrivateKey(BigInteger key) {
        if (dBackup.compareTo(BigInteger.ZERO) == 0) dBackup = d;
        d = key;
    }

    public void setPublicKey(BigInteger key) {
        if (eBackup.compareTo(BigInteger.ZERO) == 0) eBackup = e;
        e = key;
    }

    public void setCommonKeyPart(BigInteger value) {
        if (mBackup.compareTo(BigInteger.ZERO) == 0) mBackup = m;
        m = value;
    }

    public void restorePrivateKey() {
        if (dBackup.compareTo(BigInteger.ZERO) != 0) d = dBackup;
    }

    public void restorePublicKey() {
        if (eBackup.compareTo(BigInteger.ZERO) != 0) e = eBackup;
    }

    public void restoreCommonKeyPart() {
        if (mBackup.compareTo(BigInteger.ZERO) != 0) m = mBackup;
    }

    /**
     * Set key length to the given value. Setting new length of the key causes
     * private and public keys regeneration
     * @param length int Length in bits of the key to set (must be greater than
     * or equal to 16)
     * @return int 0 if length < 16, 1 - otherwise
     */
    public int setKeyLength(int length) {
        if (length < 16) return 0;
        keyLength = length;
        calculateParams();
        return 1;
    }

    public BigInteger getP() {
        return p;
    }
    public BigInteger getQ() {
        return q;
    }
    public BigInteger getCommonKeyPart() {
        return m;
    }
    public BigInteger getPublicKey() {
        return e;
    }
    public BigInteger getPrivateKey() {
        return d;
    }
    public int getKeyLength() {
        return keyLength;
    }
/**
     * Encrypt message using RSA public key
     * @param text byte[] Array of message bytes to encrypt. Length of array should be
     * getKeyLength()/8. If length is less then array will be expanded with zeros.
     * If length is greater then array will be trimmed
     * @return byte[] Array of encrypted message bytes
*/
    public byte[] Encrypt(byte[] text) {
        int length = keyLength/8;
        byte[] temp = new byte[length];
        for (int i=0; i<text.length; i++) temp[i] = text[i];
        BigInteger x = new BigInteger(temp);
        temp = x.modPow(e, m).toByteArray();
        byte[] res = new byte[length];
        if (temp.length > length)
            for (int i=1; i<=length; i++) res[length-i] = temp[temp.length-i];
        else
            for (int i=1; i<=temp.length; i++) res[length-i] = temp[temp.length-i];
        return res;
    }

    /**
     * Decrypt message using RSA private key
     * @param cryptText byte[] Encrypted message to decrypt. Length of array
     * should be getKeyLength()/8. If length is not equal to getKeyLength()/8
     * then result is undefined
     * @return byte[] Array of decrypted message bytes
     */
    public byte[] Decrypt(byte[] cryptText) {
        BigInteger y = new BigInteger(cryptText);
        return y.modPow(d, m).toByteArray();
    }
    /**
     * Converts sequence of bytes to its string representation in hexadecimal
     * format without sign extension
     * @param bytes byte[] sequence of bytes to convert
     * @return String hexadecimal representation of byte sequence
     */
    public static String BytesToString(byte[] bytes) {
        StringBuffer res = new StringBuffer(bytes.length*2);
        String temp = new String();
        for (int i=0; i<bytes.length; i++) {
            temp = Integer.toHexString(bytes[i]);
            if (temp.length() <= 2) {
                if (temp.length() == 1) res.append('0');
                res.append(temp);
            }
            else res.append(temp.substring(6));
        }
        return res.toString();
    }
}