Pull staff from java-interview-coding repo

Author: andrei-punko

common/pom.xml

@@ -41,6 +41,41 @@
             <artifactId>activemq-broker</artifactId>
             <version>${activemq.version}</version>
         </dependency>
+
+        <!-- Staff for REST client. Selected versions are compatible for Java6u45 -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-web</artifactId>
+            <version>4.1.9.RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+            <version>4.5.14</version>
+        </dependency>
+        <dependency>
+            <groupId>org.bouncycastle</groupId>
+            <artifactId>bcprov-jdk15on</artifactId>
+            <version>1.54</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>2.14.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>4.10.0</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.jasypt</groupId>
+            <artifactId>jasypt</artifactId>
+            <version>1.9.3</version>
+        </dependency>
     </dependencies>
 
     <build>

common/src/main/java/by/andd3dfx/digitalsignature/DigitalSignatureUtil.java

@@ -0,0 +1,122 @@
+package by.andd3dfx.digitalsignature;
+
+import java.io.BufferedInputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.security.*;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.security.spec.X509EncodedKeySpec;
+
+public class DigitalSignatureUtil {
+
+    /**
+     * According to documentation - https://docs.oracle.com/javase/8/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
+     * possible cases for algorithm are next: DiffieHellman, DSA, RSA, EC
+     */
+    public KeyPair generateKeysPair(String algorithm, int keysize) throws Exception {
+        KeyPairGenerator keyGenerator = KeyPairGenerator.getInstance(algorithm);
+        SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
+        keyGenerator.initialize(keysize, random);
+        return keyGenerator.generateKeyPair();
+    }
+
+    /**
+     * Store private & public keys from keys pair to files
+     */
+    public void storeKeysToFiles(KeyPair keyPair, String privateKeyFilename, String publicKeyFilename) throws IOException {
+        PrivateKey privateKey = keyPair.getPrivate();
+        PublicKey publicKey = keyPair.getPublic();
+
+        saveToFile(privateKeyFilename, privateKey.getEncoded());
+        saveToFile(publicKeyFilename, publicKey.getEncoded());
+    }
+
+    private void saveToFile(String filename, byte[] data) throws IOException {
+        FileOutputStream publicKeyFileOutputStream = new FileOutputStream(filename);
+        publicKeyFileOutputStream.write(data);
+        publicKeyFileOutputStream.close();
+    }
+
+    private byte[] loadFromFile(String filename) throws IOException {
+        FileInputStream fileInputStream = new FileInputStream(filename);
+        byte[] result = new byte[fileInputStream.available()];
+        fileInputStream.read(result);
+        fileInputStream.close();
+        return result;
+    }
+
+    public PrivateKey loadPrivateKeyFromFile(String algorithm, String privateKeyFilename) throws Exception {
+        byte[] encKey = loadFromFile(privateKeyFilename);
+        PKCS8EncodedKeySpec encodedKeySpec = new PKCS8EncodedKeySpec(encKey);
+
+        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
+        return keyFactory.generatePrivate(encodedKeySpec);
+    }
+
+    public PublicKey loadPublicKeyFromFile(String algorithm, String publicKeyFilename) throws Exception {
+        byte[] encKey = loadFromFile(publicKeyFilename);
+        X509EncodedKeySpec encodedKeySpec = new X509EncodedKeySpec(encKey);
+
+        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
+        return keyFactory.generatePublic(encodedKeySpec);
+    }
+
+    /**
+     * Sign string with definite algorithm and privateKey.
+     * Usage: signString("SHA256withECDSA", privateKey, "Some string ...")
+     */
+    public byte[] signString(String algorithm, PrivateKey privateKey, String stringTiSign) throws Exception {
+        Signature dsa = Signature.getInstance(algorithm);
+        dsa.initSign(privateKey);
+
+        byte[] strByte = stringTiSign.getBytes("UTF-8");
+        dsa.update(strByte);
+
+        return dsa.sign();
+    }
+
+    /**
+     * Sign file with definite algorithm and privateKey.
+     * Usage: signFile("SHA256withECDSA", privateKey, "d:/some-filename.txt")
+     */
+    public byte[] signFile(String algorithm, PrivateKey privateKey, String nameOfFileToSign) throws Exception {
+        Signature dsa = Signature.getInstance(algorithm);
+        dsa.initSign(privateKey);
+
+        FileInputStream fis = new FileInputStream(nameOfFileToSign);
+        BufferedInputStream bufferedInputStream = new BufferedInputStream(fis);
+        byte[] buffer = new byte[1024];
+
+        int len;
+        while ((len = bufferedInputStream.read(buffer)) >= 0) {
+            dsa.update(buffer, 0, len);
+        }
+        bufferedInputStream.close();
+        return dsa.sign();
+    }
+
+    public String convertBytesArrayToString(byte[] signature) {
+        return new BigInteger(1, signature).toString(16);
+    }
+
+    public boolean verifyStringSignature(String algorithm, PublicKey publicKey, String signedString, byte[] signature) throws Exception {
+        Signature sig = Signature.getInstance(algorithm);
+        sig.initVerify(publicKey);
+        sig.update(signedString.getBytes("UTF-8"));
+        return sig.verify(signature);
+    }
+
+    public boolean verifyFileSignature(String algorithm, PublicKey publicKey, String signedFileName, byte[] signatureToVerify) throws Exception {
+        FileInputStream fileInputStream = new FileInputStream(signedFileName);
+        byte[] bytes = new byte[fileInputStream.available()];
+        fileInputStream.read(bytes);
+        fileInputStream.close();
+
+        Signature sig = Signature.getInstance(algorithm);
+        sig.initVerify(publicKey);
+        sig.update(bytes);
+        return sig.verify(signatureToVerify);
+    }
+}