Skip to content

Commit 43afcc2

Browse files
claudius108claudius108
committed
Renamed some classes.
1 parent e608474 commit 43afcc2

14 files changed

Lines changed: 466 additions & 190 deletions

File tree

src/main/java/ro/kuberam/libs/java/crypto/certificates/GenerateCertificationPath.java renamed to src/main/java/ro/kuberam/libs/java/crypto/certificates/ConstructCertificationPath.java

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -20,13 +20,14 @@
2020
package ro.kuberam.libs.java.crypto.certificates;
2121

2222
import java.security.cert.CertPath;
23+
import java.security.cert.Certificate;
2324
import java.security.cert.CertificateException;
2425
import java.security.cert.CertificateFactory;
2526
import java.util.Arrays;
2627

27-
public class GenerateCertificationPath {
28+
public class ConstructCertificationPath {
2829

29-
public static CertPath createCertPath(java.security.cert.Certificate[] certs) {
30+
public static CertPath run(Certificate[] certs) {
3031
try {
3132
CertificateFactory certFact = CertificateFactory.getInstance("X.509");
3233
CertPath path = certFact.generateCertPath(Arrays.asList(certs));

‎src/main/java/ro/kuberam/libs/java/crypto/digitalSignature/ValidateSignatureOnBinary.java‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -36,11 +36,12 @@ public static byte[] generateSignatureOnBinary(final byte[] data, final PrivateK
3636
return dsa.sign();
3737
}
3838

39-
public static boolean validateSignatureOnBinary(final byte[] data, final PublicKey publicKey,
40-
final byte[] signature, final String algorithm) throws Exception {
41-
final Signature signer = Signature.getInstance(algorithm);
39+
public static boolean validateSignatureOnBinary(byte[] data, PublicKey publicKey,
40+
byte[] signature, String algorithm) throws Exception {
41+
Signature signer = Signature.getInstance(algorithm);
4242
signer.initVerify(publicKey);
4343
signer.update(data);
44+
4445
return signer.verify(signature);
4546

4647
}

‎src/main/java/ro/kuberam/libs/java/crypto/encrypt/AsymmetricEncryption.java‎

Lines changed: 68 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,6 @@
2525
import java.io.ByteArrayOutputStream;
2626
import java.io.IOException;
2727
import java.io.InputStream;
28-
import java.security.InvalidAlgorithmParameterException;
2928
import java.security.InvalidKeyException;
3029
import java.security.KeyFactory;
3130
import java.security.NoSuchAlgorithmException;
@@ -35,16 +34,13 @@
3534
import java.security.spec.InvalidKeySpecException;
3635
import java.security.spec.PKCS8EncodedKeySpec;
3736
import java.security.spec.X509EncodedKeySpec;
38-
import java.util.Optional;
37+
import java.util.Base64;
3938
import java.util.StringTokenizer;
4039

41-
import javax.annotation.Nullable;
4240
import javax.crypto.BadPaddingException;
4341
import javax.crypto.Cipher;
4442
import javax.crypto.IllegalBlockSizeException;
4543
import javax.crypto.NoSuchPaddingException;
46-
import javax.crypto.spec.IvParameterSpec;
47-
import javax.crypto.spec.SecretKeySpec;
4844

4945
import ro.kuberam.libs.java.crypto.CryptoException;
5046
import ro.kuberam.libs.java.crypto.utils.Buffer;
@@ -55,97 +51,111 @@
5551
*/
5652
public class AsymmetricEncryption {
5753

58-
public static String encryptString(String input, String publicKey, String transformationName)
54+
public static String encryptString(String data, String base64PublicKey, String transformationName)
5955
throws CryptoException, IOException {
60-
try (InputStream bais = new ByteArrayInputStream(input.getBytes(UTF_8))) {
61-
return encrypt(bais, publicKey, transformationName);
56+
String provider = "SUN";
57+
58+
try (InputStream bais = new ByteArrayInputStream(data.getBytes(UTF_8))) {
59+
return encrypt(bais, base64PublicKey, transformationName, provider);
6260
}
6361
}
6462

65-
public static String encrypt(InputStream input, String privateKey, String transformationName)
63+
public static String encryptString(String data, String base64PublicKey, String transformationName, String provider)
6664
throws CryptoException, IOException {
65+
InputStream dataIs = new ByteArrayInputStream(data.getBytes(UTF_8));
6766
String algorithm = transformationName.split("/")[0];
68-
String provider = "SUN";
67+
byte[] resultBytes = null;
6968

7069
Cipher cipher;
7170
try {
7271
cipher = Cipher.getInstance(transformationName);
73-
} catch (NoSuchAlgorithmException | NoSuchPaddingException e) {
74-
throw new CryptoException(e);
75-
}
72+
PublicKey publicKey = loadPublicKey(base64PublicKey, algorithm, provider);
73+
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
7674

77-
try {
78-
PrivateKey privateKey1 = loadPrivateKey(privateKey, algorithm, provider);
79-
cipher.init(Cipher.ENCRYPT_MODE, privateKey1);
80-
} catch (InvalidKeyException e) {
75+
byte[] buf = new byte[Buffer.TRANSFER_SIZE];
76+
int read = -1;
77+
while ((read = dataIs.read(buf)) > -1) {
78+
cipher.update(buf, 0, read);
79+
}
80+
resultBytes = cipher.doFinal();
81+
} catch (IllegalBlockSizeException | BadPaddingException | NoSuchAlgorithmException | NoSuchPaddingException
82+
| InvalidKeyException e) {
8183
throw new CryptoException(e);
8284
} catch (Exception e) {
8385
e.printStackTrace();
8486
}
8587

86-
byte[] resultBytes;
88+
return Base64.getEncoder().encodeToString(resultBytes);
89+
}
90+
91+
public static String encrypt(InputStream data, String base64PublicKey, String transformationName, String provider)
92+
throws CryptoException, IOException {
93+
String algorithm = transformationName.split("/")[0];
94+
byte[] resultBytes = null;
95+
96+
Cipher cipher;
8797
try {
98+
cipher = Cipher.getInstance(transformationName);
99+
PublicKey publicKey = loadPublicKey(base64PublicKey, algorithm, provider);
100+
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
101+
88102
byte[] buf = new byte[Buffer.TRANSFER_SIZE];
89103
int read = -1;
90-
while ((read = input.read(buf)) > -1) {
104+
while ((read = data.read(buf)) > -1) {
91105
cipher.update(buf, 0, read);
92106
}
93107
resultBytes = cipher.doFinal();
94-
} catch (IllegalBlockSizeException | BadPaddingException e) {
108+
} catch (IllegalBlockSizeException | BadPaddingException | NoSuchAlgorithmException | NoSuchPaddingException
109+
| InvalidKeyException e) {
95110
throw new CryptoException(e);
111+
} catch (Exception e) {
112+
e.printStackTrace();
96113
}
97114

98115
return getString(resultBytes);
99116
}
100117

101-
public static String decryptString(String encryptedInput, String plainKey, String transformationName, String iv,
102-
@Nullable String provider) throws CryptoException, IOException {
118+
public static String decryptString(String encryptedInput, String base64PrivateKey, String transformationName)
119+
throws CryptoException, IOException {
120+
String provider = "SUN";
121+
103122
try (InputStream bais = new ByteArrayInputStream(getBytes(encryptedInput))) {
104-
return decrypt(bais, plainKey, transformationName, iv, provider);
123+
return decrypt(bais, base64PrivateKey, transformationName, provider);
105124
}
106125
}
107126

108-
public static String decrypt(InputStream encryptedInput, String plainKey, String transformationName, String iv,
109-
@Nullable String provider) throws CryptoException, IOException {
110-
String algorithm = transformationName.split("/")[0];
127+
public static String decryptString(String data, String base64PrivateKey, String transformationName, String provider)
128+
throws CryptoException, IOException {
129+
try (InputStream bais = new ByteArrayInputStream(getBytes(data))) {
130+
return decrypt(bais, base64PrivateKey, transformationName, provider);
131+
}
132+
}
111133

112-
String actualProvider = Optional.ofNullable(provider).filter(str -> !str.isEmpty()).orElse("SunJCE");
134+
public static String decrypt(InputStream data, String base64PrivateKey, String transformationName, String provider)
135+
throws CryptoException, IOException {
136+
String algorithm = transformationName.split("/")[0];
137+
byte[] resultBytes = null;
113138

114139
Cipher cipher;
115140
try {
116-
cipher = Cipher.getInstance(transformationName, actualProvider);
117-
} catch (NoSuchProviderException | NoSuchAlgorithmException | NoSuchPaddingException e) {
118-
throw new CryptoException(e);
119-
}
120-
121-
SecretKeySpec skeySpec = new SecretKeySpec(plainKey.getBytes(UTF_8), algorithm);
122-
if (transformationName.contains("/")) {
123-
IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes(UTF_8), 0, 16);
124-
try {
125-
cipher.init(Cipher.DECRYPT_MODE, skeySpec, ivSpec);
126-
} catch (InvalidAlgorithmParameterException | InvalidKeyException e) {
127-
throw new CryptoException(e);
128-
}
129-
} else {
130-
try {
131-
cipher.init(Cipher.DECRYPT_MODE, skeySpec);
132-
} catch (InvalidKeyException e) {
133-
throw new CryptoException(e);
134-
}
135-
}
141+
cipher = Cipher.getInstance(transformationName);
142+
PrivateKey publicKey = loadPrivateKey(base64PrivateKey, algorithm, provider);
143+
cipher.init(Cipher.DECRYPT_MODE, publicKey);
136144

137-
try {
138145
byte[] buf = new byte[Buffer.TRANSFER_SIZE];
139146
int read = -1;
140-
while ((read = encryptedInput.read(buf)) > -1) {
147+
while ((read = data.read(buf)) > -1) {
141148
cipher.update(buf, 0, read);
142149
}
143-
144-
byte[] resultBytes = cipher.doFinal();
145-
return new String(resultBytes, UTF_8);
146-
} catch (IllegalBlockSizeException | BadPaddingException e) {
150+
resultBytes = cipher.doFinal();
151+
} catch (IllegalBlockSizeException | BadPaddingException | NoSuchAlgorithmException | NoSuchPaddingException
152+
| InvalidKeyException e) {
147153
throw new CryptoException(e);
154+
} catch (Exception e) {
155+
e.printStackTrace();
148156
}
157+
158+
return getString(resultBytes);
149159
}
150160

151161
public static String getString(byte[] bytes) {
@@ -171,30 +181,28 @@ public static byte[] getBytes(String str) throws IOException {
171181
}
172182
}
173183

174-
private static PublicKey loadPublicKey(String keyString, String algorithm, String provider)
184+
private static PublicKey loadPublicKey(String base64PublicKey, String algorithm, String provider)
175185
throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {
176-
byte[] keyBytes = keyString.getBytes(UTF_8);
177186
// provider = Optional.ofNullable(provider).filter(str ->
178187
// !str.isEmpty()).orElse("SunRsaSign");
179188
provider = "SunRsaSign";
180189

181-
X509EncodedKeySpec spec = new X509EncodedKeySpec(keyBytes);
190+
X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.getDecoder().decode(base64PublicKey.getBytes(UTF_8)));
182191
KeyFactory kf = KeyFactory.getInstance(algorithm, provider);
183192

184193
return kf.generatePublic(spec);
185194
}
186195

187-
private static PrivateKey loadPrivateKey(String keyString, String algorithm, String provider)
196+
private static PrivateKey loadPrivateKey(String base64PrivateKey, String algorithm, String provider)
188197
throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException {
189-
byte[] keyBytes = keyString.getBytes(UTF_8);
190198
// provider = Optional.ofNullable(provider).filter(str ->
191199
// !str.isEmpty()).orElse("SunRsaSign");
192200
provider = "SunRsaSign";
193201

194-
PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);
202+
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(base64PrivateKey.getBytes(UTF_8)));
195203

196204
KeyFactory kf = KeyFactory.getInstance(algorithm, provider);
197205

198-
return kf.generatePrivate(spec);
206+
return kf.generatePrivate(keySpec);
199207
}
200208
}

‎src/main/java/ro/kuberam/libs/java/crypto/keyManagement/GenerateKeyPair.java‎

Lines changed: 5 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -27,14 +27,12 @@
2727
import java.security.PublicKey;
2828
import java.security.spec.PKCS8EncodedKeySpec;
2929
import java.security.spec.X509EncodedKeySpec;
30-
import java.util.Arrays;
31-
32-
import ro.kuberam.libs.java.crypto.randomSequencesGeneration.RandomNumber;
33-
3430
import java.util.Base64;
3531
import java.util.HashMap;
3632
import java.util.Map;
3733

34+
import ro.kuberam.libs.java.crypto.randomSequencesGeneration.RandomNumber;
35+
3836
public class GenerateKeyPair {
3937
private static Base64.Encoder encoder = Base64.getEncoder();
4038

@@ -68,17 +66,14 @@ private static String outputPublickey(byte[] publicKey, String algorithm) {
6866
}
6967

7068
public static String savePrivateKey(PrivateKey priv) throws GeneralSecurityException {
71-
KeyFactory fact = KeyFactory.getInstance("RSA");
69+
KeyFactory fact = KeyFactory.getInstance("EllipticCurve");
7270
PKCS8EncodedKeySpec spec = fact.getKeySpec(priv, PKCS8EncodedKeySpec.class);
73-
byte[] packed = spec.getEncoded();
74-
String key64 = Base64.getEncoder().encodeToString(packed);
75-
Arrays.fill(packed, (byte) 0);
7671

77-
return key64;
72+
return Base64.getEncoder().encodeToString(spec.getEncoded());
7873
}
7974

8075
public static String savePublicKey(PublicKey publ) throws GeneralSecurityException {
81-
KeyFactory fact = KeyFactory.getInstance("RSA");
76+
KeyFactory fact = KeyFactory.getInstance("EllipticCurve");
8277
X509EncodedKeySpec spec = fact.getKeySpec(publ, X509EncodedKeySpec.class);
8378

8479
return Base64.getEncoder().encodeToString(spec.getEncoded());

src/main/java/ro/kuberam/libs/java/crypto/toDo/ListAvailableCryptographicServices.java renamed to src/main/java/ro/kuberam/libs/java/crypto/providers/ListAvailableCryptographicServices.java

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@
2222
* and open the template in the editor.
2323
*/
2424

25-
package ro.kuberam.libs.java.crypto.toDo;
25+
package ro.kuberam.libs.java.crypto.providers;
2626

2727
/**
2828
* @author claudius

‎src/test/java/ro/kuberam/libs/java/crypto/CryptoModuleTests.java‎

Lines changed: 16 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -21,17 +21,29 @@
2121

2222
import static java.nio.charset.StandardCharsets.UTF_8;
2323

24+
import java.io.IOException;
25+
import java.net.URISyntaxException;
26+
import java.nio.file.Files;
2427
import java.nio.file.Path;
2528
import java.nio.file.Paths;
2629

2730
import ro.kuberam.tests.junit.BaseTest;
2831

2932
public class CryptoModuleTests extends BaseTest {
30-
31-
protected static String longInput = "Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests.";
32-
protected static byte[] longInputBytes = longInput.getBytes(UTF_8);
33+
34+
protected static String longString = "Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests.";
35+
protected static String veryLongString;
36+
protected static byte[] longInputBytes = longString.getBytes(UTF_8);
3337
protected static String sunProvider = "SunJCE";
3438
protected static Path rsaPrivateKeyFile = Paths.get("rsa-private-key.key").toAbsolutePath();
3539
protected static Path rsaPublicKeyFile = Paths.get("rsa-public-key.key").toAbsolutePath();
40+
41+
static {
42+
try {
43+
veryLongString = new String(
44+
Files.readAllBytes(Paths.get(CryptoModuleTests.class.getResource("very-long-string.txt").toURI())), UTF_8);
45+
} catch (IOException | URISyntaxException e) {
46+
e.printStackTrace();
47+
}
48+
}
3649
}
37-

‎src/test/java/ro/kuberam/libs/java/crypto/encrypt/AsymmetricEncryptionTest.java‎

Lines changed: 12 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -21,27 +21,28 @@
2121

2222
import static java.nio.charset.StandardCharsets.UTF_8;
2323

24-
import java.io.InputStream;
24+
import java.nio.file.Files;
25+
import java.nio.file.Paths;
2526

26-
import org.apache.commons.io.IOUtils;
27-
import org.junit.Ignore;
2827
import org.junit.Test;
2928

3029
import ro.kuberam.libs.java.crypto.CryptoModuleTests;
3130

3231
public class AsymmetricEncryptionTest extends CryptoModuleTests {
3332

34-
@Ignore
3533
@Test
3634
public void encryptStringWithRsaAsymmetricKey() throws Exception {
37-
try (InputStream is = getClass().getResourceAsStream("../rsa-private-key.key")) {
38-
String privateKey = IOUtils.toString(is, UTF_8);
39-
System.out.println("privateKey = " + privateKey);
35+
String transformation = "RSA/ECB/NoPadding";
36+
String publicKey = new String(
37+
Files.readAllBytes(Paths.get(getClass().getResource("../rsa-public-key.key").toURI())), UTF_8);
38+
String privateKey = new String(
39+
Files.readAllBytes(Paths.get(getClass().getResource("../rsa-private-key.key").toURI())), UTF_8);
4040

41-
String result = AsymmetricEncryption.encryptString(longInput, privateKey,
42-
"RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
4341

44-
System.out.println(result);
45-
}
42+
String encryptedText = AsymmetricEncryption.encryptString(longString, publicKey, transformation);
43+
String decryptedText = AsymmetricEncryption.decryptString(encryptedText, privateKey, transformation);
44+
45+
System.out.println(encryptedText);
46+
System.out.println(decryptedText);
4647
}
4748
}

0 commit comments

Comments
 (0)