package elte.java2_utikalauz5.math;

import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.math.*;
import java.util.*;

/**
RSA algoritmus segítségével kódoló demo-applet.
<P align="center"><APPLET code="elte.java2_utikalauz5.math.RSAClient.class"
archive="{@docRoot}/../data/math/RSAClient.jar" width=500 height=500>
</APPLET></P>
Egyszerű applet, ami a RSA algoritmus segítségével üzeneteket
képes kódolni és visszakódolni. A titkos és a nyilvános kulcsokat
az applet maga is tud generálni, de már meglévő kulcsok beolvasására
is lehetőséget ad a program.

@link.forrásfájl {@docRoot}/../data/math/src RSAClient.java
@link.letöltés {@docRoot}/../data/math RSAClient.jar
@since Java 2 Útikalauz programozóknak
*/
public class RSAClient extends Applet implements ActionListener {

    /** Verziószám. */
    private final static long serialVersionUID = 15L;

    class Keys {


    	// Az egyet BigIntegerként ábrázoljuk
    	private final BigInteger ONE = new BigInteger("1");

    	// A nyilvános kulcs
    	private BigInteger p;

    	// A titkos kulcs
    	private BigInteger s;

    	// A moduló értéke
    	private BigInteger N;

    	// Véletlen számként generát prím
    	private BigInteger x;

    	// Véletlen számként generált prím
    	private BigInteger y;


    	public Keys() {
    		x = new BigInteger(64, 99, new Random());
    		y = new BigInteger(64, 99, new Random());
    		s = new BigInteger(64, 99, new Random());

    		// Moduló kiszámításához egy 1-0,5^100 valószínűséggel prímet állítunk elő
    		while(!x.isProbablePrime(100)) {
    			x = new BigInteger(64, 99, new Random());
    		}

    		// Moduló kiszámításához egy 1-0,5^100 valószínűséggel prímet állítunk elő
    		while(!y.isProbablePrime(100)) {
    			y = new BigInteger(64, 99, new Random());
    		}

    		// A titkos kulcs előállítása, ami 1-0,5^100 valószínűséggel prím
    		while(!s.isProbablePrime(100)) {
    			s = new BigInteger(64, 99, new Random());
    		}

    		// A nyilvános kulcs előállítása
    		p = s.modInverse(x.subtract(ONE).multiply(y.subtract(ONE)));
    		// A moduló előállítása
    		N = x.multiply(y);
    	}


    	// Visszaadja a nyilvános kulcs értékét
    	public BigInteger getPublicKey() {
    		return p;
    	}

    	// Visszaadja a moduló értékét
    	public BigInteger getModulo() {
    		return N;
    	}

    	// Visszadaja a titkos kulcs értékét
    	public BigInteger getPrivateKey() {
    		return s;
    	}

    	// A  nyilvános kulcsot, mint egy karakterláncot ad vissza értékül
    	public String getPublicKeyString() {
    		return p.toString();
    	}

    	// A titkos kulcsot, mint egy karakterláncot adja vissza érétkül
    	public String getPrivateKeyString() {
    		return s.toString();
    	}

    	// A modulót, mint karakterláncot adja vissza értékül
    	public String getModuloString() {
    		return N.toString();
    	}

    	// Nyilvános kulcsot beolvasó metódus
    	public boolean setPublicKey(String value) {
    		try {
    			p = new BigInteger(value);
    		}
    		catch(NumberFormatException e) {
    			return false;
    		}
    		return true;
    	}

    	// Titkos kulcsot beolvasó metódus
    	public boolean setPrivateKey(String value) {
    		try {
    			s = new BigInteger(value);
    		}
    		catch(NumberFormatException e) {
    			return false;
    		}
    		return true;
    	}

    	// Modulót beolvasó metódus
    	public boolean setModulo(String value) {
    		try {
    			N = new BigInteger(value);
    		}
    		catch(NumberFormatException e) {
    			return false;
    		}
    		return true;
    	}

    } // Keys osztály vége


    static class RSA {

    	// Szöveget kódoló metódus
    	public static BigInteger[] encrypt(String message, BigInteger publickey, BigInteger modulo) {
    		byte[] temp;
    		byte[] digits = message.getBytes();

    		BigInteger[] bigdigits = new BigInteger[digits.length];

    		for (int i = 0; i < bigdigits.length; i++) {
    			temp = new byte[1];
    			temp[0] = digits[i];
    			bigdigits[i] = new BigInteger(temp);
    		}

    		BigInteger[] encrypted = new BigInteger[bigdigits.length];

    		try {
    			for(int j = 0; j < bigdigits.length; j++)
    				encrypted[j] = bigdigits[j].modPow(publickey, modulo);
    		}
    		catch(Exception e) {
    			return null;
    		}

    		return encrypted;
    	}

    	// Kódolt szöveg visszafejtését végző metódus
    	public static String decrypt(BigInteger[] encrypted, BigInteger privatekey, BigInteger modulo) {
    		BigInteger[] decrypted = new BigInteger[encrypted.length];

    		try {
    			for(int i = 0; i < decrypted.length; i++)
    				decrypted[i] = new BigInteger(encrypted[i].toString()).modPow(privatekey, modulo);
    		}
    		catch(Exception e) {
    			return null;
    		}

    		char[] array = new char[decrypted.length];

    		for(int j = 0; j < array.length; j++)
    			array[j] = (char)(decrypted[j].intValue());

    		return new String(array);
    	}

    } // RSA osztály vége

//Változók definiálása
	// Az adatmező
	private Keys keys;
	private Font f;
	private String message;
	private String decrypted;
	private BigInteger[] encrypted;

	// A grafikus felhasználói felület elemei
	//Cimkék
	private Label titlelabel = new Label("RSA algoritmussal kódoló applet");
	private Label statuslabel =  new Label("Állapot: ");
	private Label messagelabel = new Label("Üzenet:");
	private Label publickeylabel = new Label("Nyilvános kulcs:");
	private Label privatekeylabel = new Label("Titkos kulcs:");

	//Szövegmezők
	private TextField publickeyfield = new TextField(40);
	private TextField privatekeyfield = new TextField(40);

	private TextArea textarea = new TextArea("", 8, 40, TextArea.SCROLLBARS_VERTICAL_ONLY);

	//Nyomógombok
	private Button encryptbutton = new Button("Kódolás");
	private Button decryptbutton = new Button("Dekódolás");
	private Button generatebutton = new Button("Új kulcsok");
	private Button setpublicbutton = new Button("Nyilvános kulcs beolvasása");
	private Button setprivatebutton = new Button("Titkos kulcs beolvasása");

//A felhasználói felülethez kapcsolodó metódusok

	// Applet indítása
	public void init() {

		// Font beállítás
		f = new Font("Serif", Font.PLAIN, 24);
		titlelabel.setFont(f);

		f = new Font("SansSerif", Font.PLAIN, 14);
		statuslabel.setFont(f);

		// Inicializáljuk a Layout manager-t
		GridBagLayout gbl = new GridBagLayout();
		GridBagConstraints gbc = new GridBagConstraints();

		setLayout(gbl);

		// A komponenseket feltesszük a felhasználói felületre
		gbc.gridx = 0;
		gbc.gridy = 0;
		gbc.gridwidth = 3;
		gbc.insets.bottom = 8;
		gbl.setConstraints(titlelabel, gbc);
		add(titlelabel);

		gbc.gridx = 0;
		gbc.gridy = 1;
		gbc.insets.bottom = 0;
		gbc.fill = GridBagConstraints.HORIZONTAL;
		gbc.anchor = GridBagConstraints.WEST;
		gbl.setConstraints(messagelabel, gbc);
		add(messagelabel);

		gbc.gridx = 0;
		gbc.gridy = 2;
		gbl.setConstraints(textarea, gbc);
		add(textarea);

		gbc.gridx = 0;
		gbc.gridy = 3;
		gbc.insets.top = 8;
		gbl.setConstraints(publickeylabel, gbc);
		add(publickeylabel);

		gbc.gridx = 0;
		gbc.gridy = 4;
		gbc.gridwidth = 2;
		gbc.insets.top = 0;
		gbc.fill = GridBagConstraints.NONE;
		gbl.setConstraints(publickeyfield, gbc);
		add(publickeyfield);

		gbc.gridx = 2;
		gbc.gridy = 4;
		gbc.gridwidth = 1;
		gbl.setConstraints(setpublicbutton, gbc);
		add(setpublicbutton);

		gbc.gridx = 0;
		gbc.gridy = 5;
		gbc.gridwidth = 3;
		gbc.insets.top = 8;
		gbc.fill = GridBagConstraints.HORIZONTAL;
		gbl.setConstraints(privatekeylabel, gbc);
		add(privatekeylabel);

		gbc.gridx = 0;
		gbc.gridy = 6;
		gbc.gridwidth = 2;
		gbc.insets.top = 0;
		gbc.fill = GridBagConstraints.NONE;
		gbl.setConstraints(privatekeyfield, gbc);
		add(privatekeyfield);

		gbc.gridx = 2;
		gbc.gridy = 6;
		gbc.gridwidth = 1;
		gbl.setConstraints(setprivatebutton, gbc);
		add(setprivatebutton);

		Panel p = new Panel();
		p.add(encryptbutton);
		p.add(decryptbutton);
		p.add(generatebutton);

		gbc.gridx = 0;
		gbc.gridy = 7;
		gbc.gridwidth = 3;
		gbc.insets.top = 0;
		gbc.fill = GridBagConstraints.HORIZONTAL;
		gbl.setConstraints(p, gbc);
		add(p);

		encryptbutton.addActionListener(this);
		decryptbutton.addActionListener(this);
		generatebutton.addActionListener(this);
		setpublicbutton.addActionListener(this);
		setprivatebutton.addActionListener(this);

		gbc.gridx = 0;
		gbc.gridy = 8;
		gbc.insets.top = 8;
		gbc.anchor = GridBagConstraints.WEST;
		gbl.setConstraints(statuslabel, gbc);
		add(statuslabel);
	}
	// Új nyilvános kulcspár generáló metódus
	public void getKeys() {

		statuslabel.setText("Állapot: Új kulcsok készítése");

		keys = new Keys();

		publickeyfield.setText(keys.getPublicKeyString());
		privatekeyfield.setText(keys.getPrivateKeyString());

		statuslabel.setText("Állapot:a kulcsok készen vannak");
	}


	// Az üzenetet beolvassa a képernyőröl és kódoláshoz előkészíti
	public BigInteger[] getEncryptedText() {

		BigInteger[] temp;
		StringTokenizer tok;
		Vector<String> v = new Vector<String>();
		String s = new String();

		// Az üzenet beolvasása a szöveg mezőből
		String messagetext = new String(textarea.getText());

		// A felesleges whitespace-től megszabadulunk
		tok = new StringTokenizer(messagetext);
		while(tok.hasMoreTokens()) {
			s = s.concat(tok.nextToken());
		}

		// A beolvasott szöveget megfelelő méretű darabokra tördeljük
		tok = new StringTokenizer(s, "|");
		while(tok.hasMoreTokens()) {
			v.addElement(tok.nextToken());
		}

		// A darabokat egy vektorba tesszük, ezzel előkészítjük a kódoló metódusnak
		temp = new BigInteger[v.size()];
		for(int j = 0; j < temp.length; j++) {
			temp[j] = new BigInteger((String)(v.elementAt(j)));
		}

		return temp;
	}

	//Kódoló metódus
	public void doEncryption() {

		if(keys == null) {
			statuslabel.setText("Állapot: HIBA, nincsen aktív kulcspár");
			return;
		}

		// Beolvassuk a szöveget és kódoljuk
		message = textarea.getText();
		// Meghívjuk az RSA osztály kódoló metódusát
		encrypted = RSA.encrypt(message, keys.getPublicKey(), keys.getModulo());

		if(encrypted != null) {

			// A szöveget a kódolt szöveggel helyettesítjük
			textarea.setText("");

			for(int i = 0; i < encrypted.length; i++)
				textarea.append(encrypted[i].toString() + "|");

			statuslabel.setText("Állapot: a szöveg sikerült lekódolni");
		} else {
			statuslabel.setText("Állapot: HIBA történt a kódolás alatt");
		}
	}

//Dekódoló eljárás
	public void doDecryption() {

		// Ellenőrizzük a kulcsokat
		if(keys == null) {
			statuslabel.setText("Állapot: HIBA, nincsen aktív kulcspár");
			return;
		}

		// az RSA osztály dekódoló eljárása segítségével visszafejtük a szöveget
		decrypted = RSA.decrypt(encrypted, keys.getPrivateKey(), keys.getModulo());

		if(decrypted != null) {

			// Megjelenítjük a dekódolt üzenetet
			textarea.setText(decrypted);

			statuslabel.setText("Állapot: a szöveg sikeresen visszafejtve");
		} else {
			statuslabel.setText("Állapot: HIBA lépett fel a dekódolás alatt");
		}
	}

//Esemény kezelés
	public void actionPerformed(ActionEvent e) {
		if(e.getSource() == generatebutton) {

			// Új kulcspár készítése
			getKeys();
		} else if(e.getSource() == encryptbutton) {

			// Kódolás
			doEncryption();
		} else if(e.getSource() == decryptbutton) {

			// Dekódolás és a szöveg megjelenítése
			encrypted = getEncryptedText();
			doDecryption();
		} else if(e.getSource() == setpublicbutton) {

			// Nyilvános kulcs beállítása
			if(keys == null) keys = new Keys();
			statuslabel.setText("Állapot: nyilvános kulcs beolvasása");

			if (keys.setPublicKey(publickeyfield.getText()))
				statuslabel.setText("Állapot: nyilvános kulcs beolvasva");
			else
				statuslabel.setText("Állapot: HIBA, helytelen nyilvános kulcs forma");
		} else if(e.getSource() == setprivatebutton) {

			// A titkos kulcs beállítása
			if(keys == null) keys = new Keys();
			statuslabel.setText("Állapot: titkos kulcs beolvasása");

			if (keys.setPrivateKey(privatekeyfield.getText()))
				statuslabel.setText("Állapot: titkos kulcs beolvasva");
			else
				statuslabel.setText("Állapot: HIBA, helytelen titkos kulcs forma");
		}
	}

} // RSAClient osztály vége