您可以简单地从RFC4253中获取格式，但您需要从RFC4251中找出mpint（多预置整数）格式。

这是Java的事情（Java），仅仅是因为JSch库太可怕了。

package nl.owlstead.crypto;

import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.RSAPublicKeySpec;
import java.util.Arrays;
import java.util.Base64;
import java.util.Base64.Encoder;

public class SSHPublicKeyDecoder {

    private static byte[] SSH_RSA_HEADER = "ssh-rsa".getBytes(StandardCharsets.US_ASCII);

    private static RSAPublicKey decodeRSAPublicKey(byte[] encodedRSAPublicKey)
            throws NoSuchAlgorithmException, InvalidKeySpecException {
        ByteBuffer buf = ByteBuffer.wrap(encodedRSAPublicKey);
        
        byte[] header = getSSHEncodedValueFromBuffer(buf);
        if (!Arrays.equals(header, SSH_RSA_HEADER)) {
            throw new IllegalArgumentException("Not an RSA public key");
        }
        
        byte[] eDataSigned = getSSHEncodedValueFromBuffer(buf);
        BigInteger e = new BigInteger(eDataSigned);
        
        byte[] nDataSigned = getSSHEncodedValueFromBuffer(buf);
        BigInteger n = new BigInteger(nDataSigned);
        
        KeyFactory rsaKeyFactory;
        try {
            rsaKeyFactory = KeyFactory.getInstance("RSA");
        } catch (NoSuchAlgorithmException ex) {
            throw new IllegalStateException(
                    "KeyFactory should exist for RSA", ex);
        }
        
        RSAPublicKeySpec spec = new RSAPublicKeySpec(n, e);
        return (RSAPublicKey) rsaKeyFactory.generatePublic(spec);
    }

    private static byte[] getSSHEncodedValueFromBuffer(ByteBuffer buf) {
        int size = buf.getInt();
        if (size < 0) {
            throw new IllegalArgumentException("Bad SSH encoded value in format");
        }
        byte[] data = new byte[size];
        buf.get(data);
        return data;
    }

    private static byte[] toUnsigned(BigInteger value) {
        if (value.compareTo(BigInteger.ZERO) <= 0) {
            throw new IllegalArgumentException("Negative numbers cannot be encoded as unsigned integers");
        }
        
        if (value.equals(BigInteger.ZERO)) {
            return value.toByteArray();
        }
        
        final byte[] signedBigEndian = value.toByteArray();
        
        if (signedBigEndian[0] == 0x00) {
            return Arrays.copyOfRange(signedBigEndian, 1, signedBigEndian.length);
        }
        
        return signedBigEndian;
    }

    private SSHPublicKeyDecoder() {
        
    }
    
    public static void main(String[] args) throws Exception {
        String[] parts = args[0].split("\\s+");
        String part2 = parts[1];
        byte[] encodedRSAPublicKey = Base64.getDecoder().decode(part2);
        
        RSAPublicKey pubKey = decodeRSAPublicKey(encodedRSAPublicKey);
        String format = encodeServerPublicKey(pubKey);
        
        System.out.println(format);
    }

    private static String encodeServerPublicKey(RSAPublicKey pubKey) {
        byte[] nData = toUnsigned(pubKey.getModulus());
        byte[] eData = toUnsigned(pubKey.getPublicExponent());
        
        Encoder base64Encoder = Base64.getEncoder();
        String format = String.format(
                "{\"modulus\":\"%s\",\"exponent\":\"%s\"}%n",
                base64Encoder.encodeToString(nData),
                base64Encoder.encodeToString(eData));
        return format;
    }
}