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