Estou usando o flexiprovider para criptografar / de com algoritmo assimétrico baseado na curva elíptica após estatutorial. Com uma pequena modificação, vou converter a chave pública e privada em Base64 para fins pessoais (como armazenar no banco de dados ou arquivo de texto). Eu também estou olhando issoPergunta, questão e a resposta é se referir a issofio. Mas meu código está sendo executado para o dekstop não no dispositivo android, a versão android e dekstop em java eu acho que é realmente uma grande diferença (apenas para limpar as informações da minha pergunta). Ok, no meu código, quando vou criar a chave pública formatada a partir de uma chave pública gerada, recebi um erro (acho que o mesmo problema acontecerá quando eu tentar fazer isso para a chave privada). Agora, aqui está o meu código:

Classe de gerador de par de chaves.

import org.jivesoftware.smack.util.Base64; //or whatever to convert into Base64
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.KeyFactory;
import javax.crypto.Cipher;   
import de.flexiprovider.common.ies.IESParameterSpec;
import de.flexiprovider.core.FlexiCoreProvider;
import de.flexiprovider.ec.FlexiECProvider;
import de.flexiprovider.ec.parameters.CurveParams;
import de.flexiprovider.ec.parameters.CurveRegistry.BrainpoolP160r1;
import de.flexiprovider.pki.PKCS8EncodedKeySpec;
import de.flexiprovider.pki.X509EncodedKeySpec;
...
  Security.addProvider(new FlexiCoreProvider());
  Security.addProvider(new FlexiECProvider());

  KeyPairGenerator kpg = KeyPairGenerator.getInstance("ECIES","FlexiEC");

  CurveParams ecParams = new BrainpoolP160r1();

  kpg.initialize(ecParams, new SecureRandom());
  KeyPair keyPair = kpg.generateKeyPair();

  PublicKey pubKey = keyPair.getPublic();
  byte[] encod_pubK = pubKey.getEncoded();

  String publicKey = Base64.encodeBytes(encod_pubK);
  System.out.println("Public Key :" +publikKey);

  PrivateKey privKey = keyPair.getPrivate();
  byte[] encod_privK = privKey.getEncoded();
  String privateKey = Base64.encodeBytes(encod_privK);
  System.out.println("Private Key :" +privateKey);

A partir desse código acima, vou armazenar a string "privateKey" e "publicKey". Agora vou criptografar a mensagem.

Lado do Remetente

import (same as code above)
...
  Security.addProvider(new FlexiCoreProvider());
  Security.addProvider(new FlexiECProvider());
  Cipher cipher = Cipher.getInstance("ECIES","FlexiEC");
  IESParameterSpec iesParams = new IESParameterSpec ("AES128_CBC","HmacSHA1", null, null);

  byte[] decodedPubKey = Base64.decode(publicKey);

  X509EncodedKeySpec formatted_public = new X509EncodedKeySpec(decodedPubKey);
  KeyFactory kf = KeyFactory.getInstance("ECIES","FlexiEC");

  PublicKey publicKey = kf.generatePublic(formatted_public); // <--- I got error when hit this row

  cipher.init(Cipher.ENCRYPT_MODE, publicKey, iesParams);

  byte[] block = "this my message".getBytes();
  System.out.println("Plaintext: "+ new String(block));

  byte [] Ciphered = cipher.doFinal(block);
  System.out.println("Ciphertext : "+ Base64.encodeBytes(Ciphered));

O erro desse código de remetente acima é:

Exception in thread "main" de.flexiprovider.api.exceptions.InvalidKeySpecException:     java.lang.RuntimeException: java.security.InvalidAlgorithmParameterException: Caught IOException("Unknown named curve: 1.3.36.3.3.2.8.1.1.1")
at de.flexiprovider.ec.keys.ECKeyFactory.generatePublic(ECKeyFactory.java:205)
at de.flexiprovider.api.keys.KeyFactory.engineGeneratePublic(KeyFactory.java:39)
at java.security.KeyFactory.generatePublic(KeyFactory.java:328)

Como posso gerar essa chave pública com essa curva nomeada: 1.3.36.3.3.2.8.1.1.1?

Lado do destinatário (apenas para outra informação)

Se o remetente foi criptografado com êxito, agora eu vou descriptografar a mensagem, aqui está o meu código (mas não tenho certeza se isso está sendo executado sem um erro como o código do remetente acima):

 byte[] decodedPrivateKey = Base64.decode(privateKey);
 PKCS8EncodedKeySpec formatted_private = new PKCS8EncodedKeySpec(decodedPrivateKey);

 cipher.init(Cipher.DECRYPT_MODE, privKey, iesParams);
 byte[] decryptedCipher = cipher.doFinal(Ciphered);
 System.out.println("Decrypted message : "+ new String (decryptedCipher));