/* Group Master
////////////////////
    GQ_IDS GQ_crypto = new GQ_IDS(2048);
    Pair<byte[], byte[]> pvKeyUser = GQ_crypto.deriveKey("user");
    BigInteger n = GQ_crypto.getN();
    BigInteger v = GQ_crypto.getV();
*/

/* User
////////////////////
    GQ_IDS GQ_crypto = new GQ_IDS(n,v,J,B);
    Pair<byte[], byte[]> sig = GQ_crypto.sign("Hello world!");
    boolean verificationResult = GQ_crypto.verify("user","Hello world!",sig);
*/


import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Random;
import android.util.Pair;


public class GQ_IDS {

    private BigInteger p;
    private BigInteger q;
    private BigInteger n;
    private BigInteger phi_n;
    private BigInteger v;
    private BigInteger v_inverse;
    private int l;
    private BigInteger vk;
    private BigInteger J;
    private BigInteger B;

    public GQ_IDS(){}

    public GQ_IDS(int bitLength)
    {
        Random rnd = new Random();
        p = BigInteger.probablePrime(bitLength/2, rnd);
        q = BigInteger.probablePrime(bitLength/2, rnd);

        n = p.multiply(q);
        phi_n = p.subtract(BigInteger.ONE).multiply(q.subtract(BigInteger.ONE));

        v = new BigInteger("65537");

        l=16;
        vk = v.pow(l);
        v_inverse = v.modInverse(phi_n);
    }

    public BigInteger getN() {
        return n;
    }

    public BigInteger getV() {
        return v;
    }


    public GQ_IDS(BigInteger n, BigInteger v, BigInteger J, BigInteger B)
    {
        this.n = n;
        this.v = v;
        this.J = J;
        this.B = B;

        l=16;
        vk = v.pow(l);
    }

    public Pair<byte[], byte[]> deriveKey(String ID)  throws NoSuchAlgorithmException {
        MessageDigest myDigest = MessageDigest.getInstance("SHA-256");

        J = new BigInteger(myDigest.digest(ID.getBytes())).mod(n);
        B = J.modPow(v_inverse.multiply(new BigInteger("-1")),n);

        return new Pair<byte[], byte[]> (B.toByteArray(),J.toByteArray());
    }


    public Pair<byte[], byte[]> sign(String mes) throws NoSuchAlgorithmException {


        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] message_hash = digest.digest(mes.getBytes());
        BigInteger hm = new BigInteger(message_hash).abs();

        Random rnd = new Random();
        BigInteger r = new BigInteger(n.bitLength(),rnd);

        BigInteger T = r.modPow(v,n);
        BigInteger d = J.modPow(hm,n).multiply(T.modPow(vk,n)).mod(n);
        BigInteger t = r.multiply(B.modPow(d,n)).mod(n);

        /* signature is (d,t) */
        return new Pair<byte[], byte[]>(d.toByteArray(), t.toByteArray());
    }

    public boolean verify(String ID, String mes, Pair<byte[], byte[]> sig) throws NoSuchAlgorithmException {
        /* signature is (d,t) */
        /* verification */
        BigInteger d = new BigInteger(sig.first);
        BigInteger t = new BigInteger(sig.second);

        MessageDigest digest = MessageDigest.getInstance("SHA-256");

        byte[] message_hash = digest.digest(ID.getBytes());
        BigInteger hID = new BigInteger(message_hash).abs();
        BigInteger J = hID;

        message_hash = digest.digest(mes.getBytes());
        BigInteger hm = new BigInteger(message_hash).abs();

        BigInteger JD = J.modPow(d, n);
        BigInteger tv = t.modPow(v, n);
        BigInteger TT = JD.multiply(tv).mod(n);
        BigInteger JM = J.modPow(hm, n);
        BigInteger Tv = TT.modPow(vk, n);
        BigInteger dd = JM.multiply(Tv).mod(n);
        BigInteger ver = JM.multiply(J.modPow(vk.multiply(dd),n).multiply(tv.modPow(vk,n))).mod(n);


        if (ver.equals(d)) return true;
        else return false;
    }

    public boolean verify(String mes, Pair<byte[], byte[]> sig) throws NoSuchAlgorithmException {
        /* signature is (d,t) */
        /* verification */
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] message_hash = digest.digest(mes.getBytes());
        BigInteger hm = new BigInteger("2").pow(256).add(new BigInteger(message_hash).mod(n)).pow(2);

        BigInteger d = new BigInteger(sig.first);
        BigInteger t = new BigInteger(sig.second);

        BigInteger TT = J.modPow(d,n).multiply(t.modPow(v,n)).mod(n);
        BigInteger dd = J.modPow(hm,n).multiply(TT.modPow(v.pow(2),n)).mod(n);
        BigInteger ver = J.modPow(hm.add(d.multiply(v.pow(2))),n).multiply(t.modPow(v.pow(3),n)).mod(n);
        if (ver.equals(d)) return true;
        else return false;
    }

}