Java - PKCS12 - usare privateKey per firmare un documento

Salve. Dopo aver risolto la prima parte del mio progetto dovrei:

1) (lato client) prelevare la chiave privata da un file .p12 per firmare un documento.

2) (lato server) prelevare la chiave pubblica dal mio keystore, relativa a quell'utente per poter verificare la firma del documento

Sono fermo al primo punto...

il codice più simile a quello che chiedi che ho qui a portata di mano è qui sotto.
non è esattamente quello che ti serve ma forse è una partenza per adattarlo.

/**
	 * Carica la chiave privata da un keystore<br>
	 * 
	 * @param pathKeystore file contenente il keystore
	 * @param password password del keystore
	 * @param alias alias dell'entry del keystor(Ë il nome passato all'argomento -alias quando si usa keytool)
	 * @param keyPass password con cui Ë protetta la chiave privata associata 
	 * @throws CertificateException
	 * @throws FileNotFoundException
	 * @throws IOException
	 * @throws KeyStoreException
	 * @throws NoSuchAlgorithmException
	 * @throws UnrecoverableKeyException
	 */
	public void loadPrivateKeyFromKeyStore(String pathKeystore, String password, String alias, String keyPass) throws CertificateException, FileNotFoundException, IOException, KeyStoreException, NoSuchAlgorithmException, UnrecoverableKeyException {
		KeyStore ks = KeyStore.getInstance("JKS");
		ks.load(new FileInputStream(pathKeystore), password.toCharArray());
		privateKey = (PrivateKey) ks.getKey(alias, keyPass.toCharArray());
	}
	
	/**
	 * Carica in memoria la chiave pubblica da un certificato
	 * <br>
	 * @param certificateFilename file .cer contenente le informazioni
	 * @throws GeneralSecurityException
	 * @throws IOException
	 */
	public void loadPublicKeyFromCertificate(String certificateFilename) throws GeneralSecurityException, IOException{
		
		//Carica il certificato dallo stream
		
		CertificateFactory certFactory = CertificateFactory.getInstance("X.509");
		FileInputStream fis = new FileInputStream(certificateFilename);
		Certificate myCert = certFactory.generateCertificate(fis);
		fis.close();

		//Legge la chiave pubblica del certificato
		this.publicKey = myCert.getPublicKey();
	}

Per il primo punto ho fatto questa classe:

PrivateKSign.java

public class PrivateKSign {
	
    private String caAlias = "";
    private char[] caPassword;
    private String caFile;
    private String aliasIn = "cliente";
    private String storeFile = "my-store.keystore";
    private String keyStorePass = "storepass";
    private String fileDaFirmare;
	
    public PrivateKSign(char[] pass, String store, String filedaFirmare, String fileCliente) {
		
        caPassword = pass;
        storeFile = store;
        fileDaFirmare = filedaFirmare;
        caFile = fileCliente;
		
    }
	
    public void Firma() {
		
        byte[] documentToSign = null;
		
        try {
			
            //Load del file my-ca.p12
            KeyStore caKs = KeyStore.getInstance("PKCS12");
            caKs.load(new FileInputStream(new File(caFile)), caPassword);
			
			
            //Test sull'esistenza del keystore
            if (new File(storeFile).exists()) {
				
				
                //Se il keystore esiste effettuo il load
                System.out.println("Ho trovato keystore - file: " + storeFile);
                KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
                FileInputStream in = new FileInputStream(storeFile);
                ks.load(in, keyStorePass.toCharArray());
				
                PrivateKey prvkey = (PrivateKey) caKs.getKey(caAlias, caPassword);
				
                in.close();
				
                try {
					
                    // Estraggo il certificato relativo all'alias CA (aliasIN - vedi dopo)
                    java.security.cert.Certificate cert = ks.getCertificate(aliasIn);
					
                    if (cert != null) {
						
                        System.out.println("Trovato certificato di " + aliasIn + " nel keystore - file: " + "AHAHAHAHAHAH");
						
                        // Prendo il file da firmare
						
						
                        File file = new File(fileDaFirmare);
                        FileInputStream fileStream = new FileInputStream(file);
                        try {
                            int fileSize = (int) file.length();
                            byte[] data = new byte[fileSize];
                            int bytesRead = 0;
                            while (bytesRead < fileSize) {
                                bytesRead += fileStream.read(data, bytesRead, fileSize-bytesRead);
                            }
                            documentToSign = data;
                        } catch (Exception e) {
                            System.out.println(e.toString());
                        } finally {
                            fileStream.close();
                        }
						
						
                        // APRO CERTIFICATO
						
						
                        Signature sig = Signature.getInstance("SHA1withRSA");
                        sig.initSign(prvkey);
						
                        sig.update(documentToSign);
						
                        byte[] signature = sig.sign();
                        System.out.println("Generated signature for file 'certificato.p12'");
                        FileOutputStream fos = new FileOutputStream("nuovo");
                        fos.write(signature);
                        fos.close();
                        System.out.println("Wrote PKCS#12 signature file  'nuovo'  (" + signature.length + " bytes)");
						
						
                        sig.initVerify(cert.getPublicKey());
                        sig.update(documentToSign);
                        if (sig.verify(signature)) {
                            System.out.println("Signature verified!");
                        }
						
                    } else {
						
                        System.out.println("Non ho trovato certificato di " + aliasIn + " nel keystore - file: " + storeFile);
                    }
					
                } //catch (UnrecoverableKeyException e) { System.out.println(e.toString());}
                //catch (NoSuchAlgorithmException e) { System.out.println(e.toString()); }
                catch (KeyStoreException e) {
                    System.out.println(e.toString());
                } catch (Exception e) {
                    System.out.println(e.toString());
                }
				
            } else {
				
                System.out.println("NIENTE KEYSTORE");
            }
        } catch (UnrecoverableKeyException e) {
            System.out.println(e.toString());
        } catch (NoSuchAlgorithmException e) {
            System.out.println(e.toString());
        } catch (KeyStoreException e) {
            System.out.println(e.toString());
        } catch (Exception e) {
            System.out.println(e.toString());
        }
    }
}

Mi serve il secondo punto... eh eh eh.

Adesso però mi chiedo... è possibile quando creo lato server il certificato per il cliente, salvarmi la SOLA chiave pubblica del cliente in un mio keystore?