1 package civitas.crypto;
2
3 import static org.mockito.ArgumentMatchers.any;
4 import static org.mockito.ArgumentMatchers.argThat;
5 import static org.mockito.ArgumentMatchers.eq;
6 import static org.mockito.Mockito.doAnswer;
7 import static org.mockito.Mockito.doThrow;
8 import static org.mockito.Mockito.mock;
9 import static org.mockito.Mockito.when;
10
11 import java.security.InvalidKeyException;
12 import java.security.KeyFactory;
13 import java.security.KeyPair;
14 import java.security.KeyPairGenerator;
15 import java.security.Signature;
16 import java.security.SignatureException;
17 import java.security.spec.InvalidKeySpecException;
18 import java.util.Random;
19
20 import javax.crypto.Cipher;
21 import javax.crypto.KeyGenerator;
22 import javax.crypto.SecretKeyFactory;
23
24 import civitas.common.RandomAnswer;
25 import civitas.common.RandomFillerAnswer;
26 import civitas.crypto.parameters.ElGamalParametersTestData;
27 import civitas.crypto.publickeyciphertext.PublicKeyCiphertextTestData;
28 import civitas.crypto.rsaprivatekey.KeySpecMatcher;
29 import civitas.crypto.rsaprivatekey.KeySpecMatcherPrivate;
30 import civitas.crypto.rsaprivatekey.PrivateKeyTestData;
31 import civitas.crypto.rsapublickey.PublicKeyTestData;
32 import civitas.crypto.sharedkey.SharedKeyTestData;
33 import civitas.crypto.sharedkeyciphertext.SharedKeyCiphertextTestData;
34 import civitas.crypto.signature.SignatureTestData;
35
36 public class CryptoBaseStub
37 implements PrivateKeyTestData,
38 PublicKeyTestData,
39 SharedKeyTestData,
40 SignatureTestData,
41 ElGamalParametersTestData,
42 SharedKeyCiphertextTestData,
43 PublicKeyCiphertextTestData {
44
45 public static CryptoBase stub() throws InvalidKeySpecException, SignatureException, InvalidKeyException {
46 CryptoBase mock = mock(CryptoBase.class);
47 mock.publicKeyFactory = mock(KeyFactory.class);
48 mock.sharedKeyFactory = mock(SecretKeyFactory.class);
49 mock.rsaSigner = mock(Signature.class);
50 when(mock.publicKeyFactory.generatePublic(argThat(new KeySpecMatcher(KEYSPEC_PUBLIC))))
51 .thenReturn(PUBLIC_KEY);
52 when(mock.publicKeyFactory.generatePublic(argThat(new KeySpecMatcher(KEYSPEC_PUBLIC_BAD))))
53 .thenThrow(new InvalidKeySpecException());
54 when(mock.publicKeyFactory.generatePrivate(argThat(new KeySpecMatcherPrivate(KEYSPEC_PRIVATE2))))
55 .thenThrow(new InvalidKeySpecException());
56 when(mock.publicKeyFactory.generatePrivate(argThat(new KeySpecMatcherPrivate(KEYSPEC_PRIVATE))))
57 .thenReturn(PRIVATE_KEY);
58 when(mock.sharedKeyFactory.generateSecret(SHARED_KEY_SPEC)).thenReturn(SHARED_KEY_JS);
59 when(mock.sharedKeyFactory.generateSecret(SHARED_KEY_SPEC_BAD)).thenThrow(new InvalidKeySpecException());
60 when(mock.rsaSigner.sign()).thenReturn(SIGNATURE_OF_AUTH_NONCE_WITH_KEY_BYTES);
61 when(mock.rsaSigner.verify(SIGNATURE_OF_AUTH_NONCE_WITH_KEY_BYTES)).thenReturn(true);
62 when(mock.rsaSigner.verify(SIGNATURE_OF_SOMESTRING_WITH_KEY_BYTES)).thenReturn(true);
63 doThrow(new InvalidKeyException()).when(mock.rsaSigner).initSign(PRIVATE_KEY_BAD);
64 doThrow(new InvalidKeyException()).when(mock.rsaSigner).initVerify(PUBLIC_KEY_BAD);
65
66 when(mock.obtainProbablePrime(eq(EL_GAMAL_KEY_LENGTH)))
67 .thenReturn(BIGINT_B)
68 .thenReturn(BIGINT_NO_PRIME_OF_KEYLENGTH)
69 .thenReturn(BIGINT_Q)
70 .thenThrow(new NullPointerException());
71 when(mock.obtainProbablePrime(eq(SAFE_KEY_LENGTH))).thenReturn(BIGINT_B).thenReturn(SAFE_Q);
72
73 when(mock.doCrypto(
74 PUBLIC_KEY_CIPHER_ALG,
75 PUBLIC_KEY_PROVIDER,
76 PUBLIC_KEY,
77 Cipher.ENCRYPT_MODE,
78 SOMESTRING.getBytes()))
79 .thenReturn(SOMESTRING_ENCRYPTED_BYTES);
80 when(mock.doCrypto(
81 PUBLIC_KEY_CIPHER_ALG,
82 PUBLIC_KEY_PROVIDER,
83 PRIVATE_KEY,
84 Cipher.DECRYPT_MODE,
85 SOMESTRING_ENCRYPTED_BYTES))
86 .thenReturn(SOMESTRING.getBytes());
87 when(mock.doCrypto(
88 SHARED_KEY_CIPHER_ALG,
89 SHARED_KEY_PROVIDER,
90 SHARED_KEY_SPEC,
91 Cipher.ENCRYPT_MODE,
92 SOMESTRING.getBytes()))
93 .thenReturn(SHARED_KEY_CIPHERTEXT_BYTES);
94 when(mock.doCrypto(
95 SHARED_KEY_CIPHER_ALG,
96 SHARED_KEY_PROVIDER,
97 SHARED_KEY_SPEC,
98 Cipher.DECRYPT_MODE,
99 SHARED_KEY_CIPHERTEXT_BYTES))
100 .thenReturn(SOMESTRING.getBytes());
101
102 when(mock.generateRandomElement(any())).thenAnswer(new RandomAnswer());
103 when(mock.generateRandomElement(TWO_EXP_GROUP_LENGTH))
104 .thenReturn(BIGINT_A)
105 .thenReturn(BIGINT_NO_PRIME_OF_GROUPLENGTH)
106 .thenReturn(BIGINT_A)
107 .thenReturn(BIGINT_A)
108 .thenReturn(BIGINT_NO_PRIME_OF_GROUPLENGTH)
109 .thenReturn(BIGINT_P)
110 .thenThrow(new NullPointerException());
111 when(mock.generateRandomElement(BIGINT_P))
112 .thenReturn(ONE)
113 .thenReturn(BIGINT_P.subtract(ONE))
114 .thenReturn(BIGINT_D);
115
116 Random randomMock = mock(Random.class);
117 doAnswer(new RandomFillerAnswer()).when(randomMock).nextBytes(any());
118 when(randomMock.nextInt(SOME_SMALL_INT)).thenReturn(SOME_SMALL_INT - 1);
119 when(mock.getRandomGenerator()).thenReturn(randomMock);
120
121 KeyPair keypair = mock(KeyPair.class);
122 when(keypair.getPrivate()).thenReturn(PRIVATE_KEY);
123 when(keypair.getPublic()).thenReturn(PUBLIC_KEY);
124 KeyPairGenerator generator = mock(KeyPairGenerator.class);
125 when(generator.generateKeyPair()).thenReturn(keypair);
126 when(mock.getPublicKeyGenerator(KEYSIZE)).thenReturn(generator);
127
128 KeyGenerator sharedGenerator = mock(KeyGenerator.class);
129 when(sharedGenerator.generateKey()).thenReturn(SHARED_KEY_SPEC);
130 when(mock.getSharedKeyGenerator(SHARED_KEY_SIZE)).thenReturn(sharedGenerator);
131
132 return mock;
133 }
134 }