OIC - RSA sign and verify java code for OCI Function

Java code:

package com.test.fn;

import java.security.*;

import java.security.spec.*;

import java.util.Base64;

import java.util.logging.*;

import java.security.MessageDigest;

public class RSASignVerify {

    private static final Logger logger =

        Logger.getLogger(RSASignVerify.class.getName());

    public static class Input {

        public String message;

        public String signatureBase64;

        public String publicKeyBase64;

        public String privateKeyBase64;

        public String hashType;

        public String actionType; //SIGN or VERIFY

        public String messageType; // BASE64 or TEXT or MESSAGE_TO_DIGEST

    }

    public static class Result {

        public boolean verifyResult;

        public String signatureBase64;

        public String executionInfo;

    }

}

/**

 * Verifies an RSA signature.

 *

 * @param Input

 * The original data that was signed.

 * signatureBase64 The signature in Base64 encoding.

 * publicKeyBase64 The RSA public key in Base64 encoding (X.509 format).

 * HashType Hashing value to Initialize the Signature object for verification, SHA256withRSA.

 *

 * @return true if the signature is valid, false otherwise.

 * @throws Exception on errors during verification.

 */

public Result verifyMessage(Input input) throws Exception {

    Result result = new Result();

    try {

        // Decode the public key

        byte[] publicKeyBytes = Base64.getDecoder().decode(input.publicKeyBase64);

        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance("RSA");

        PublicKey publicKey = keyFactory.generatePublic(keySpec);

        // Decode the signature

        byte[] signatureBytes = Base64.getDecoder().decode(input.signatureBase64);

        // Initialize the Signature object for verification with SHA256withRSA

        Signature signature = Signature.getInstance(input.hashType);

        signature.initVerify(publicKey);

if("BASE64".equals(input.messageType)){

    byte [] messageBytes = Base64.getDecoder().decode(input.message);

    signature.update(messageBytes);

}else if ("MESSAGE_TO_DIGEST".equals(input.messageType)){

    signature.update(getDigestBytes(input.message));

}else{

    signature.update(input.message.getBytes("UTF-8"));

}

// Verify the signature

result.verifyResult = signature.verify(signatureBytes);

result.executionInfo = "SUCCESS";

} catch(Exception e) {

    result.verifyResult = false;

    result.executionInfo = e.getMessage();

    System.out.println("Error Details:" + e.getMessage());

}

return result;

}

public Result signMessage(Input input) throws Exception {

    Result result = new Result();

    try {

        // Decode the private key

        byte[] keyBytes = Base64.getDecoder().decode(input.privateKeyBase64);

        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);

        KeyFactory keyFactory = KeyFactory.getInstance("RSA");

        PrivateKey privateKey=keyFactory.generatePrivate(spec);

        // Initialize the Signature object for verification with SHA256withRSA

        Signature signature = Signature.getInstance(input.hashType);

        signature.initSign(privateKey);

        //sign message

        if("BASE64".equals(input.messageType)){

            byte [] messageBytes = Base64.getDecoder().decode(input.message);

            signature.update(messageBytes);

        }else{

            signature.update(input.message.getBytes("UTF-8"));

        }

        byte[] signedBytes = signature.sign();

        //generate signature

        result.signatureBase64 = Base64.getEncoder().encodeToString(signedBytes);

        result.executionInfo = "SUCCESS";

} catch (Exception e) {

result.executionInfo = e.getMessage();

System.out.println("Error Details:" + e.getMessage());

}

return result;

}

//For FPS

public static byte[] getDigestBytes (String message) throws Exception {

MessageDigest digest = MessageDigest.getInstance("SHA-256");

}

digest.update (message.getBytes());

byte[] message_digest = digest.digest();

return message_digest;

public Result handleRequest (Input input) throws Exception {

logger.log(Level.INFO, "OIC message:", input.message);

logger.log (Level.INFO, "OIC actionType:", input.actionType);

Result result = null;

if ("SIGN".equals(input.actionType)) {

result = signMessage (input);

} else if ("VERIFY".equals(input.actionType)) {

result = verifyMessage(input);

} else {

result = new Result();

result.executionInfo = "ERROR: No proper action found, possible value "

+ input.actionType;

+ "is ENCRYPT or DECRYPT recieved value:"

}

return result;

}}

Code screenshots: