Digital-Credentials-in-Java/DLVerifier.java at main · ielmie/Digital-Credentials-in-Java · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

/*The code is implemented by Siavash Khalaj (skhal045@uottawa.ca) based on
 “Introduction to Privacy Enhancing Technologies“ (pages 124-130) by Professor Carlisle Adams*/

import org.bouncycastle.util.BigIntegers;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;


public class DLVerifier {

    public BigInteger verifierC;

    public boolean verifySignature(DLUser user) throws NoSuchAlgorithmException {
        BigInteger gZeroCZeroPrime = user.discreteLogCA.g0.modPow(user.cZeroPrime, user.discreteLogCA.prime);
        BigInteger hRZeroPrime = user.h.modPow(user.rZeroPrime, user.discreteLogCA.prime);
        BigInteger toBeConcatenated = (gZeroCZeroPrime.multiply(hRZeroPrime)).mod(user.discreteLogCA.prime);
        BigInteger verification = concatenateBigIntegersHashed(user.h, toBeConcatenated);
        boolean result = verification.equals(user.cZeroPrime);
        if(!result){
            System.out.println("Signature Cannot Be Verified");
        }
        return result;
    }

    public BigInteger concatenateBigIntegersHashed(BigInteger a, BigInteger b) throws NoSuchAlgorithmException {

        byte[] aStringBytes = a.toByteArray();
        byte[] bStringBytes = b.toByteArray();
        byte[] concatBytesArray = new byte[aStringBytes.length + bStringBytes.length];
        for (int i = 0; i < aStringBytes.length; ++i) {
            concatBytesArray[i] = aStringBytes[i];
        }
        int index = 0;

        for (int i = aStringBytes.length; i < concatBytesArray.length; ++i) {
            concatBytesArray[i] = bStringBytes[index];
            index += 1;
        }
        MessageDigest hash = MessageDigest.getInstance("sha-256");
        byte[] resultBytes = hash.digest(concatBytesArray);
        return new BigInteger(1, resultBytes);

    }

    public BigInteger getVerifierC(DLUser user) {
        verifierC =  BigIntegers.createRandomInRange(BigInteger.TWO, user.discreteLogCA.qOrder.subtract(BigInteger.ONE), new SecureRandom());
        return verifierC;
    }

    public String stringToAscii(String str) {
        StringBuilder sum = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            sum.append(Integer.toString(str.charAt(i), 16));

        }
        return sum.toString();
    }

    public boolean verifyShownAttributes(DLUser user, String[] shownStringAttributesArray, int[] shownGeneratorsArrayIndices, int[] concealedGeneratorsArrayIndices, BigInteger cPrime, BigInteger[] concealedRsArray, BigInteger a){

        int i;
        BigInteger hRaisedToCPrime = user.h.modPow(cPrime, user.discreteLogCA.prime);
        BigInteger hRaisedToCPrimeA = (hRaisedToCPrime.multiply(a)).mod(user.discreteLogCA.prime);
        BigInteger shownGeneratorsRaisedToShownXAttributes = BigInteger.ONE;
        BigInteger[] shownXAttributesArray = new BigInteger[shownStringAttributesArray.length];
        for(i=0; i< shownXAttributesArray.length; ++i){
            shownXAttributesArray[i]= new BigInteger(stringToAscii(shownStringAttributesArray[i]) ,16);
        }


        for(i = 0; i<shownXAttributesArray.length; ++i){
            shownGeneratorsRaisedToShownXAttributes = shownGeneratorsRaisedToShownXAttributes.multiply(user.discreteLogCA.generatorsArray[shownGeneratorsArrayIndices[i]].modPow((shownXAttributesArray[i].multiply(verifierC)), user.discreteLogCA.prime));
        }


        BigInteger concealedGeneratorsRaisedToConcealedRs = BigInteger.ONE;
        for(i=0; i< concealedGeneratorsArrayIndices.length; ++i){
            concealedGeneratorsRaisedToConcealedRs = concealedGeneratorsRaisedToConcealedRs.multiply(user.discreteLogCA.generatorsArray[
                    concealedGeneratorsArrayIndices[i]].modPow(concealedRsArray[i], user.discreteLogCA.prime)
            );
        }

        BigInteger hZeroRaisedToC = user.discreteLogCA.hZero.modPow(verifierC, user.discreteLogCA.prime);

        BigInteger verification = hZeroRaisedToC.multiply(concealedGeneratorsRaisedToConcealedRs).multiply(shownGeneratorsRaisedToShownXAttributes);
        verification = verification.mod(user.discreteLogCA.prime);

        boolean result = verification.equals(hRaisedToCPrimeA);
        if(!result){
            System.out.println("Attribute(s) Cannot Be Verified");
        }

        return result;

    }

    public boolean verifyShownAttributes(DLUser user, int ... shownAttributesIndices) throws NoSuchAlgorithmException {

        return user.showAttributes(this, shownAttributesIndices);

    }
}