Cifrado RSA: ¿Cómo crear el archivo de certificado ".arm" para la clave pública?

Ni .arm ni .key son extensiones estándar. Debería ser más específico sobre quién / qué generó .key archivos y quién / qué va a usar .arm archivos.

Solo puedo adivinar que .arm se refiere a "armadura ASCII", que es una antigua jerga PGP para Base64, un formato donde solo se usan caracteres ASCII de 7 bits.

El formato PEM es exactamente eso. Suponiendo que los archivos .key están codificados en DER (binario), intente usar openssl para convertir su certificado a formato PEM:

openssl x509 -inform der -in certificate.key -out certificate.arm

No tengas miedo de ser nuevo, te has topado con uno extraño.

Juro que he visto * .arm usado como una extensión, pero no a menudo. Normalmente, los certificados (que incluyen la clave pública como parte de los datos) se almacenan en un binario (comúnmente llamado DER) o como ASCII (comúnmente llamado PEM). Lo más probable es que un certificado * .arm sea uno de esos, con suerte sin formato adicional.

Aquí hay un resumen rápido de los tipos de almacenamiento realmente comunes junto con algunas instrucciones de línea de comandos para uno de las herramientas de código abierto más comunes para la manipulación de certificados - OpenSSL.

Probablemente valga la pena preguntar cuál será el consumidor de estos datos, obtener acceso al software o un kit de prueba y realizar pruebas. Intenta una codificación PEM o DER básica y cambia el tipo de archivo a * .arm solo para ver si funciona. Dado que esto no es estándar, es posible que deba consultar a las partes interesadas que necesitan este requisito para ver si pueden proporcionarle el formato de este ... lamentablemente, puede terminar desarrollándolo usted mismo, a menos que también puedan hacerlo. eres una API para generarlo ...

El siguiente código solucionó mi problema.

import java.security.PrivateKey;

import java.security.PublicKey;

import com.dds.security.KeyCreator;

import com.dds.security.KeyReader;

import com.dds.security.SecurityUtil;
import java.io.*;

    import sun.security.x509.*;
    import java.security.cert.*;
    import java.security.*;
    import java.math.BigInteger;
    import java.nio.charset.Charset;
    import java.util.Date;
        /** 
         * Create a self-signed X.509 Certificate
         * @param dn the X.509 Distinguished Name, eg "CN=Test, L=London, C=GB"
         * @param pair the KeyPair
         * @param days how many days from now the Certificate is valid for
         * @param algorithm the signing algorithm, eg "SHA1withRSA"
         */ 
        static X509Certificate generateCertificate(String dn, KeyPair pair, int days, String algorithm)
          throws GeneralSecurityException, IOException
        {
          PrivateKey privkey = pair.getPrivate();
          X509CertInfo info = new X509CertInfo();
          Date from = new Date();
          Date to = new Date(from.getTime() + days * 86400000l);
          CertificateValidity interval = new CertificateValidity(from, to);
          BigInteger sn = new BigInteger(64, new SecureRandom());
          X500Name owner = new X500Name(dn);

          info.set(X509CertInfo.VALIDITY, interval);
          info.set(X509CertInfo.SERIAL_NUMBER, new CertificateSerialNumber(sn));
          info.set(X509CertInfo.SUBJECT, new CertificateSubjectName(owner));
          info.set(X509CertInfo.ISSUER, new CertificateIssuerName(owner));
          info.set(X509CertInfo.KEY, new CertificateX509Key(pair.getPublic()));
          info.set(X509CertInfo.VERSION, new CertificateVersion(CertificateVersion.V3));

          AlgorithmId algo = new AlgorithmId(AlgorithmId.sha1WithRSAEncryption_oid);
          info.set(X509CertInfo.ALGORITHM_ID, new CertificateAlgorithmId(algo));

          // Sign the cert to identify the algorithm that's used.
          X509CertImpl cert = new X509CertImpl(info);
          cert.sign(privkey, algorithm);

          // Update the algorith, and resign.
          algo = (AlgorithmId)cert.get(X509CertImpl.SIG_ALG);
          info.set(CertificateAlgorithmId.NAME + "." + CertificateAlgorithmId.ALGORITHM, algo);
          cert = new X509CertImpl(info);
          cert.sign(privkey, algorithm);
          return cert;
        }   


        // This method writes a certificate to a file. If binary is false, the
        // certificate is base64 encoded.
        public static void export(java.security.cert.Certificate cert, File file, boolean binary) throws IOException {

          System.out.println("Your file has been written");  
            try {
                // Get the encoded form which is suitable for exporting
                byte[] buf = cert.getEncoded();

                FileOutputStream os = new FileOutputStream(file);
                if (binary) {
                    // Write in binary form
                    os.write(buf);
                } else {
                    // Write in text form
                    Writer wr = new OutputStreamWriter(os, Charset.forName("UTF-8"));
                    wr.write("-----BEGIN CERTIFICATE-----\n");
                    wr.write(new sun.misc.BASE64Encoder().encode(buf));
                    wr.write("\n-----END CERTIFICATE-----\n");
                    wr.flush();
                }
                os.close();
            } catch (CertificateEncodingException e) {
            } catch (IOException e) {
            }
        }

        }