[SOLUCIONADO] Encriptacion con clave publica

[Mechabits]

Buenas,

Pues tengo que encriptar un fichero con la clave publica que me han enviado con el certificado. Lo tengo en un keystore guardado y todo, y el fichero lo tengo metido en un array de bytes. Exactamente lo que me pone es "La certificación contiene el base64 del fichero con el contenido". "El hash_sha1 es la codificacion base64 del sha1 del contenido binario del fichero".

Alguien podría ponerme un ejemplo por favor o pasarme alguna documentación que pueda leerme?

Gracias

[Mechabits]

Lo quería para mandar un fichero encriptado mediante RSA por un cliente web service y la solucion, por si a alguien le sirve, es esta:

Código Java:

private Cipher rsa;
PublicKey publicKey=AxisSSLSocketFactory.getPublicKey();
rsa = Cipher.getInstance("RSA/ECB/PKCS1Padding");
this.rsa.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] encrypted = blockCipher(cargarFicheroComoArrayDeBytes(arrayDeFicheros[i]),Cipher.ENCRYPT_MODE);
byte[] base64EncodedData = Base64.encodeBase64(encrypted);
String datosEncriptadosEnB64 = new String (base64EncodedData);
 

Código Java:

private static byte[] cargarFicheroComoArrayDeBytes(SmbFile file) throws Exception {
        int length = (int) file.length();
        BufferedInputStream reader = new BufferedInputStream(new SmbFileInputStream(file));
        byte[] bytes = new byte[length];
        reader.read(bytes, 0, length);
        reader.close();
        return bytes;
     }   
    
    private byte[] blockCipher(byte[] bytes, int mode) throws IllegalBlockSizeException, BadPaddingException{
        // Se inicializan 2 buffers
        // scrambled llevará a cabo los resultados intermedios
        byte[] scrambled = new byte[0];
 
        // toReturn llevará a cabo el resultado total
        byte[] toReturn = new byte[0];
        // si encriptamos, usamos bloques de 100 bytes de longitud. Desencriptar requiere bloques de 128 bytes (por ser RSA) 
        int length = (mode == Cipher.ENCRYPT_MODE)? 100 : 128;
 
        // otro buffer. Este llevará a cabo los bytes que tienen que ser modificados en este paso.
        byte[] buffer = new byte[length];
 
        for (int i=0; i< bytes.length; i++){
 
            // si llenamos nuestro array buffer tenemos nuestro bloque listo para des/encriptar.
            if ((i > 0) && (i % length == 0)){
                //ejecutamos la operación
                scrambled = rsa.doFinal(buffer);
                // añadimos el resultado a nuestro resultado total
                toReturn = append(toReturn,scrambled);
                // aqui calculamos la longitud de nuestro próximo buffer requerido.
                int newlength = length;
 
                // si newlength fuese más largo que el resto de bytes en el array de bytes, lo acortamos.
                if (i + length > bytes.length) {
                     newlength = bytes.length - i;
                }
                // limpia el buffer
                buffer = new byte[newlength];
            }
            // copia el byte a nuestro buffer
            buffer[i%length] = bytes[i];
        }
        
        // este paso es necesitado si tuvieramos un buffer de salida. Solo debería ocurrir cuando encriptaramos. 
        // Por ejemplo, nosotros encriptamos 110 bytes, 100 bytes por run significa que "olvidamos" los últimos 10 bytes. Estan en el array del buffer.
        scrambled = rsa.doFinal(buffer);
 
        // último paso antes de que podamos devolver datos modificados.
        toReturn = append(toReturn,scrambled);
 
        return toReturn;
    }
    
    private byte[] append(byte[] prefix, byte[] suffix){
        byte[] toReturn = new byte[prefix.length + suffix.length];
        for (int i=0; i< prefix.length; i++){
            toReturn[i] = prefix[i];
        }
        for (int i=0; i< suffix.length; i++){
            toReturn[i+prefix.length] = suffix[i];
        }
        return toReturn;
    }