Чтение открытого ключа PKCS # 1 или SPKI в Java без библиотек - PullRequest
Новая
       48

Чтение открытого ключа PKCS # 1 или SPKI в Java без библиотек

0 голосов
/ 17 января 2019

Мне нужно использовать открытый ключ для проверки некоторых данных в Java, но я не могу отформатировать ключ таким образом, чтобы Java могла использовать его без сторонних плагинов.

Я генерирую ключ с помощью библиотеки crypto Node.js, которая дает мне возможность PKCS#1 или SPKI, а также формат файла .pem или .der.

Я слышал, что Java не поддерживает PKCS#1 из коробки, и почти каждый ответ на StackOverflow рекомендует использовать BouncyCastle или аналогичный, но в моем случае я пишу SDK, и просто не может позволить себе использовать библиотеку только для чтения этого открытого ключа.

Итак, я сейчас читаю ключ в формате .der, так как это избавляет от необходимости вырезать заголовки PEM и декодировать ключ из base-64. Когда я запускаю это, я получаю сообщение об ошибке: 

java.security.spec.InvalidKeySpecException: java.lang.RuntimeException: error:0c0000be:ASN.1 encoding routines:OPENSSL_internal:WRONG_TAG

Вот что у меня есть (извините, это на Kotlin, а не на Java, как следует из названия) 

// Here's a key for convenience
val key = Base64.getDecoder().decode("MFUCTgF/uLsPBS13Gy7C3dPpiDF6SYCLUyyl6CFqPtZT1h5bwKR9EDFLQjG/kMiwkRMcmEeaLKe5qdj9W/FfFitwRAm/8F53pQw2UETKQI2b2wIDAQAB");

val keySpec = X509EncodedKeySpec(key)
val keyFactory = KeyFactory.getInstance("RSA")
val publicKey = keyFactory.generatePublic(keySpec) // error thrown here

val cipher = Cipher.getInstance("RSA/NONE/PKCS1Padding")
cipher.init(Cipher.DECRYPT_MODE, publicKey)

Моя лучшая идея на данный момент - установить библиотеку на стороне Node.js, которая менее проблематична, для поддержки экспорта ключа как PKCS # 8, но я решил сначала проверить, не ничего не хватает.

1 Ответ

0 голосов
/ 18 января 2019

Следующий код превращает открытый ключ в кодировке PKCS # 1 в открытый ключ в кодировке SubjectPublicKeyInfo, который представляет собой кодировку открытого ключа, принятую RSA KeyFactory с использованием X509EncodedKeySpec - в качестве SubjectPublicKeyInfo определено в спецификациях X.509.

По сути, это схема кодирования DER низкого уровня, которая

  1. упаковывает кодированный ключ PKCS # 1 в битовую строку (тег 0x03 и кодирование для количества неиспользуемых битов, значение байта 0x00);
  2. добавляет последовательность идентификатора алгоритма RSA (OID RSA + нулевой параметр) впереди - предварительно кодируется как константа байтового массива;
  3. и, наконец, помещает их в последовательность (тег 0x30).

Библиотеки не используются. На самом деле, для createSubjectPublicKeyInfoEncoding операторы импорта даже не требуются. 

import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class PKCS1ToSubjectPublicKeyInfo {

    private static final int SEQUENCE_TAG = 0x30;
    private static final int BIT_STRING_TAG = 0x03;
    private static final byte[] NO_UNUSED_BITS = new byte[] { 0x00 };
    private static final byte[] RSA_ALGORITHM_IDENTIFIER_SEQUENCE =
            {(byte) 0x30, (byte) 0x0d,
                    (byte) 0x06, (byte) 0x09, (byte) 0x2a, (byte) 0x86, (byte) 0x48, (byte) 0x86, (byte) 0xf7, (byte) 0x0d, (byte) 0x01, (byte) 0x01, (byte) 0x01,
                    (byte) 0x05, (byte) 0x00};


    public static RSAPublicKey decodePKCS1PublicKey(byte[] pkcs1PublicKeyEncoding)
            throws NoSuchAlgorithmException, InvalidKeySpecException
    {
        byte[] subjectPublicKeyInfo2 = createSubjectPublicKeyInfoEncoding(pkcs1PublicKeyEncoding);
        KeyFactory rsaKeyFactory = KeyFactory.getInstance("RSA");
        RSAPublicKey generatePublic = (RSAPublicKey) rsaKeyFactory.generatePublic(new X509EncodedKeySpec(subjectPublicKeyInfo2));
        return generatePublic;
    }

    public static byte[] createSubjectPublicKeyInfoEncoding(byte[] pkcs1PublicKeyEncoding)
    {
        byte[] subjectPublicKeyBitString = createDEREncoding(BIT_STRING_TAG, concat(NO_UNUSED_BITS, pkcs1PublicKeyEncoding));
        byte[] subjectPublicKeyInfoValue = concat(RSA_ALGORITHM_IDENTIFIER_SEQUENCE, subjectPublicKeyBitString);
        byte[] subjectPublicKeyInfoSequence = createDEREncoding(SEQUENCE_TAG, subjectPublicKeyInfoValue);

        return subjectPublicKeyInfoSequence;
    }

    private static byte[] concat(byte[] ... bas)
    {
        int len = 0;
        for (int i = 0; i < bas.length; i++)
        {
            len += bas[i].length;
        }

        byte[] buf = new byte[len];
        int off = 0;
        for (int i = 0; i < bas.length; i++)
        {
            System.arraycopy(bas[i], 0, buf, off, bas[i].length);
            off += bas[i].length;
        }

        return buf;
    }

    private static byte[] createDEREncoding(int tag, byte[] value)
    {
        if (tag < 0 || tag >= 0xFF)
        {
            throw new IllegalArgumentException("Currently only single byte tags supported");
        }

        byte[] lengthEncoding = createDERLengthEncoding(value.length);

        int size = 1 + lengthEncoding.length + value.length;
        byte[] derEncodingBuf = new byte[size];

        int off = 0;
        derEncodingBuf[off++] = (byte) tag;
        System.arraycopy(lengthEncoding, 0, derEncodingBuf, off, lengthEncoding.length);
        off += lengthEncoding.length;
        System.arraycopy(value, 0, derEncodingBuf, off, value.length);

        return derEncodingBuf;
    }   

    private static byte[] createDERLengthEncoding(int size)
    {
        if (size <= 0x7F)
        {
            // single byte length encoding
            return new byte[] { (byte) size };
        }
        else if (size <= 0xFF)
        {
            // double byte length encoding
            return new byte[] { (byte) 0x81, (byte) size };
        }
        else if (size <= 0xFFFF)
        {
            // triple byte length encoding
            return new byte[] { (byte) 0x82, (byte) (size >> Byte.SIZE), (byte) size };
        }

        throw new IllegalArgumentException("size too large, only up to 64KiB length encoding supported: " + size);
    }

    public static void main(String[] args) throws Exception
    {
        // some weird 617 bit key, which is way too small and not a multiple of 8
        byte[] pkcs1PublicKeyEncoding = Base64.getDecoder().decode("MFUCTgF/uLsPBS13Gy7C3dPpiDF6SYCLUyyl6CFqPtZT1h5bwKR9EDFLQjG/kMiwkRMcmEeaLKe5qdj9W/FfFitwRAm/8F53pQw2UETKQI2b2wIDAQAB");
        RSAPublicKey generatePublic = decodePKCS1PublicKey(pkcs1PublicKeyEncoding);
        System.out.println(generatePublic);
    }
}

Примечания:

  • NoSuchAlgorithmException, вероятно, следует поймать и положить в RuntimeException;
  • закрытый метод createDERLengthEncoding, вероятно, не должен принимать отрицательные размеры.
  • Большие ключи не были проверены, пожалуйста, подтвердите createDERLengthEncoding для них - я предполагаю, что это работает, но лучше быть в безопасности, чем потом сожалеть.
...