ECC公鑰格式詳解

本文首先介紹公鑰格式相關的若干概念/技術，隨后以示例的方式剖析DER格式的ECC公鑰，最后介紹如何使用Java生成、解析和使用ECC公鑰。

ASN.1

Abstract Syntax Notation One (ASN.1)是一種接口描述語言，提供了一種平台無關的描述數據結構的方式。ASN.1是ITU-T、ISO、以及IEC的標准，廣泛應用於電信和計算機網絡領域，尤其是密碼學領域。

ASN.1與大家熟悉的Protocol Buffers和Apache Thrift非常相似，都可以通過schema來定義數據結構，提供跨平台的數據序列化和反序列化能力。不同的是，ASN.1早在1984年就被定為標准，比這兩者要早很多年，並得到了廣泛的應用，被用來定義了很多世界范圍內廣泛使用的數據結構，有大量的RFC文檔使用ASN.1定義協議、數據格式等。比如https所使用的X.509證書結構，就是使用ASN.1定義的。

ASN.1定義了若干基礎的數據類型和結構類型：

Topic	Description
Basic Types	BIT STRING BOOLEAN INTEGER NULL OBJECT IDENTIFIER OCTET STRING
String Types	BMPString IA5String PrintableString TeletexString UTF8String
Constructed Types	SEQUENCE SET CHOICE

上述的基礎類型可以在這里找到詳盡的解釋。我們可以使用這些來描述我們自己的數據結構：

    FooQuestion ::= SEQUENCE {
        trackingNumber INTEGER,
        question       IA5String
    }

如上定義了一個名為FooQuestion的數據結構。它是一個SEQUENCE結構，包含了一個INTEGER一個IA5String
一個具體的FooQuestion可以描述為：

    myQuestion FooQuestion ::= {
        trackingNumber     5,
        question           "Anybody there?"
    }

用ASN.1定義的數據結構實例，可以序列化為二進制的BER、文本類型的JSON、XML等。

Object Identifier

Object Identifier (OID)是一項由ITU和ISO/IEC制定的標准，用來唯一標識對象、概念，或者其它任何具有全球唯一特性的東西。

一個OID表現為用.分隔的一串數字，比如橢圓曲線secp256r1的OID是這樣：

1.2.840.10045.3.1.7

其每個數字的含義如下：

iso(1) member-body(2) us(840) ansi-X9-62(10045) curves(3) prime(1) 7

OID是全局統一分配的，全部的OID可以看做一棵多叉樹，每一個有效的OID表現為樹上的一個節點。當前所有的OID可以在這里找到。

OID是ASN.1的基本類型。

BER & DER

Basic Encoding Rules (BER)是一種自描述的ASN.1數據結構的二進制編碼格式。每一個編碼后的BER數據依次由數據類型標識（Type identifier），長度描述（Length description）, 實際數據（actual Value）排列而成，即BER是一種二進制TLV編碼。TLV編碼的一個好處，是數據的解析者不需要讀取完整的數據，僅從一個不完整的數據流就可以開始解析。

Distinguished Encoding Rules (DER)是BER的子集，主要是消除了BER的一些不確定性的編碼規則，比如在BER中Boolean類型true的value字節，可以為任何小於255大於0的整數，而在DER中，value字節只能為255。DER的這種確定性，保證了一個ASN.1數據結構，在編碼為為DER后，只會有一種正確的結果。這使得DER更適合用在數字簽名領域，比如X.509中廣泛使用了DER。

關於各種ASN.1數據類型是如何被編碼為DER，可以在這里找到詳盡的解釋。

如果有DER數據需要解析查看內容，這里有一個很方便的在線工具。

用DER來編碼ASN.1小節中自定義的myQuestion如下：

0x30 0x13 0x02 0x01 0x05 0x16 0x0e 0x41 0x6e 0x79 0x62 0x6f 064 0x79 0x20 0x74 0x68 0x65 0x72 0x65 0x3f
---  ---  ---  ---  ---  ---  ---  --------------------------------------------------------------------
 ^    ^    ^    ^    ^    ^    ^                                   ^
 |    |    |    |    |    |    |                                   |
 |    |    | INTEGER | IA5STRING                                   |
 |    |    | LEN=1   | TAG     |                                   |
 |    |    |         |         |                                   |
 |    | INTEGER   INTEGER   IA5STRING                          IA5STRING
 |    | TAG       VALUE(5)  LEN=14                             VALUE("Anybody there?")
 |    |
 |    |  ----------------------------------------------------------------------------------------------
 |    |                                              ^
 |  SEQUENCE LEN=19                                  |
 |                                                   |
SEQUENCE TAG                                  SEQUENCE VALUE

PEM

DER格式是ASN.1數據的二進制編碼，計算機處理方便，但不利於人類處理，比如不方便直接在郵件正文中粘貼發送。PEM是DER格式的BASE64編碼。除此之外，PEM在DER的BASE64前后各增加了一行，用來標識數據內容。示例如下：

-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDMYfnvWtC8Id5bPKae5yXSxQTt
+Zpul6AnnZWfI2TtIarvjHBFUtXRo96y7hoL4VWOPKGCsRqMFDkrbeUjRrx8iL91
4/srnyf6sh9c8Zk04xEOpK1ypvBz+Ks4uZObtjnnitf0NBGdjMKxveTq+VE7BWUI
yQjtQ8mbDOsiLLvh7wIDAQAB
-----END PUBLIC KEY-----

X.509

X.509是一項描述公鑰證書結構的標准，廣泛使用在HTTPS協議中，定義在RFC 3280

X.509使用ASN.1來描述公鑰證書的結構，通常編碼為DER格式，也可以進一步BASE64編碼為可打印的PEM格式。V3版本的X.509結構如下：

    Certificate  ::=  SEQUENCE  {
        tbsCertificate       TBSCertificate,
        signatureAlgorithm   AlgorithmIdentifier,
        signatureValue       BIT STRING  }

    TBSCertificate  ::=  SEQUENCE  {
        version         [0]  EXPLICIT Version DEFAULT v1,
        serialNumber         CertificateSerialNumber,
        signature            AlgorithmIdentifier,
        issuer               Name,
        validity             Validity,
        subject              Name,
        subjectPublicKeyInfo SubjectPublicKeyInfo,
        issuerUniqueID  [1]  IMPLICIT UniqueIdentifier OPTIONAL,
                             -- If present, version MUST be v2 or v3
        subjectUniqueID [2]  IMPLICIT UniqueIdentifier OPTIONAL,
                             -- If present, version MUST be v2 or v3
        extensions      [3]  EXPLICIT Extensions OPTIONAL
                             -- If present, version MUST be v3
        }

   Version  ::=  INTEGER  {  v1(0), v2(1), v3(2)  }

   CertificateSerialNumber  ::=  INTEGER

   Validity ::= SEQUENCE {
        notBefore      Time,
        notAfter       Time }

   Time ::= CHOICE {
        utcTime        UTCTime,
        generalTime    GeneralizedTime }

   UniqueIdentifier  ::=  BIT STRING

   SubjectPublicKeyInfo  ::=  SEQUENCE  {
        algorithm            AlgorithmIdentifier,
        subjectPublicKey     BIT STRING  }

   Extensions  ::=  SEQUENCE SIZE (1..MAX) OF Extension

   Extension  ::=  SEQUENCE  {
        extnID      OBJECT IDENTIFIER,
        critical    BOOLEAN DEFAULT FALSE,
        extnValue   OCTET STRING  }

SubjectPublicKeyInfo

如上一節所示，SubjectPublicKeyInfo是公鑰證書格式X.509的組成部分。SubjectPublicKeyInfo結構使用ASN.1描述，其中使用了橢圓曲線公私鑰加密算法的SubjectPublicKeyInfo結構定義在RFC 5480

其結構如下：

   SubjectPublicKeyInfo  ::=  SEQUENCE  {
        algorithm            AlgorithmIdentifier,
        subjectPublicKey     BIT STRING
   }

   AlgorithmIdentifier  ::=  SEQUENCE  {
        algorithm   OBJECT IDENTIFIER,
        parameters  ANY DEFINED BY algorithm OPTIONAL
   }

可以看到AlgorithmIdentifier也是一個SEQUENCE，其parameters部分取決於algorithm的具體取值。

對不限制的ECC公鑰使用算法的場景，algorithm取值：

1.2.840.10045.2.1

即： iso(1) member-body(2) us(840) ansi-X9-62(10045) keyType(2) 1

在該種類場景下，parameters的定義如下：

    ECParameters ::= CHOICE {
        namedCurve         OBJECT IDENTIFIER
    }

即parameters指定了ECC公鑰所使用的橢圓曲線。其可選的值有：

    secp192r1 OBJECT IDENTIFIER ::= {
        iso(1) member-body(2) us(840) ansi-X9-62(10045) curves(3) prime(1) 1 }

    sect163k1 OBJECT IDENTIFIER ::= {
        iso(1) identified-organization(3) certicom(132) curve(0) 1 }

    sect163r2 OBJECT IDENTIFIER ::= {
        iso(1) identified-organization(3) certicom(132) curve(0) 15 }

    secp224r1 OBJECT IDENTIFIER ::= {
        iso(1) identified-organization(3) certicom(132) curve(0) 33 }

    sect233k1 OBJECT IDENTIFIER ::= {
        iso(1) identified-organization(3) certicom(132) curve(0) 26 }

    sect233r1 OBJECT IDENTIFIER ::= {
        iso(1) identified-organization(3) certicom(132) curve(0) 27 }

    secp256r1 OBJECT IDENTIFIER ::= {
        iso(1) member-body(2) us(840) ansi-X9-62(10045) curves(3) prime(1) 7 }

    sect283k1 OBJECT IDENTIFIER ::= {
        iso(1) identified-organization(3) certicom(132) curve(0) 16 }

    sect283r1 OBJECT IDENTIFIER ::= {
        iso(1) identified-organization(3) certicom(132) curve(0) 17 }

    secp384r1 OBJECT IDENTIFIER ::= {
        iso(1) identified-organization(3) certicom(132) curve(0) 34 }

    sect409k1 OBJECT IDENTIFIER ::= {
        iso(1) identified-organization(3) certicom(132) curve(0) 36 }

    sect409r1 OBJECT IDENTIFIER ::= {
        iso(1) identified-organization(3) certicom(132) curve(0) 37 }

    secp521r1 OBJECT IDENTIFIER ::= {
        iso(1) identified-organization(3) certicom(132) curve(0) 35 }

    sect571k1 OBJECT IDENTIFIER ::= {
        iso(1) identified-organization(3) certicom(132) curve(0) 38 }

    sect571r1 OBJECT IDENTIFIER ::= {
        iso(1) identified-organization(3) certicom(132) curve(0) 39 }

algorithm確定后，再來看下subjectPublicKey，對ECC公鑰來講，subjectPublicKey就是ECPoint：

    ECPoint ::= OCTET STRING

是長度為65字節的OCTET STRING，其中第一個字節代表ECPoint是否經過壓縮，如果為0x04，代表沒有壓縮。剩下的64個字節，前32個字節，表示ECPoint的X坐標，后32個字節表示ECPoint的Y坐標。

OCTET STRING類型的ECPoint在轉換為BIT STRING類型的subjectPublicKey時，按照大端字節序轉換。

ECC Public Key Example

我們以一個DER編碼的ECC公鑰為例，詳細剖析一下X.509 ECC公鑰的格式。公鑰內容如下：

0x30 0x59 0x30 0x13 0x06 0x07 
0x2a 0x86 0x48 0xce 0x3d 0x02 
0x01 0x06 0x08 0x2a 0x86 0x48 
0xce 0x3d 0x03 0x01 0x07 0x03 
0x42 0x00 0x04 0x13 0x32 0x8e 
0x0c 0x11 0x8a 0x70 0x1a 0x9e 
0x18 0xa3 0xa9 0xa5 0x65 0xd8 
0x41 0x68 0xce 0x2f 0x5b 0x11 
0x94 0x57 0xec 0xe3 0x67 0x76 
0x4a 0x3f 0xb9 0xec 0xd1 0x15 
0xd0 0xf9 0x56 0x8b 0x15 0xe6 
0x06 0x2d 0x72 0xa9 0x45 0x56 
0x99 0xb0 0x9b 0xb5 0x30 0x90 
0x8d 0x2e 0x31 0x0e 0x95 0x68 
0xcc 0xcc 0x19 0x5c 0x65 0x53 
0xba

通過前面的介紹，我們已經知道這是一個ASN.1格式的SubjectPublicKeyInfo的DER編碼，是一個TLV類型的二進制數據。現在我們逐層解析下：

0x30 (SEQUENCE TAG: SubjectPublicKeyInfo) 0x59 (SEQUENCE LEN=89)
        0x30 (SEQUENCE TAG: AlgorithmIdentifier) 0x13 (SEQUENCE LEN=19)
                0x06 (OID TAG: Algorithm) 0x07 (OID LEN=7)
                        0x2a 0x86 0x48 0xce 0x3d 0x02 0x01 (OID VALUE="1.2.840.10045.2.1": ecPublicKey/Unrestricted Algorithm Identifier)
                0x06 (OID TAG: ECParameters:NamedCurve) 0x08 (OID LEN=8)
                        0x2a 0x86 0x48 0xce 0x3d 0x03 0x01 0x07 (OID VALUE="1.2.840.10045.3.1.7": Secp256r1/prime256v1)
        0x03 (BIT STRING TAG: SubjectPublicKey:ECPoint) 0x42 (BIT STRING LEN=66) 0x00 (填充bit數量為0)
                0x04 (未壓縮的ECPoint)
                0x13 0x32 0x8e 0x0c 0x11 0x8a 0x70 0x1a 0x9e 0x18 0xa3 0xa9 0xa5 0x65 0xd8 0x41 0x68 0xce 0x2f 0x5b 0x11 0x94 0x57 0xec 0xe3 0x67 0x76 0x4a 0x3f 0xb9 0xec 0xd1 (ECPoint:X)
                0x15 0xd0 0xf9 0x56 0x8b 0x15 0xe6 0x06 0x2d 0x72 0xa9 0x45 0x56 0x99 0xb0 0x9b 0xb5 0x30 0x90 0x8d 0x2e 0x31 0x0e 0x95 0x68 0xcc 0xcc 0x19 0x5c 0x65 0x53 0xba (ECPoint:Y)

Java Code

本節給出使用使用Java來生成ECC公私鑰、編碼解碼ECC公私鑰、使用ECC進行簽名驗簽、加密解密相關的示例代碼供參考。在Java中使用ECC算法有以下幾點需要注意：

• JDK1.7開始內置了ECC公私鑰生成、簽名驗簽，但沒有實現加密解密，因此需要使用BouncyCastle來做Security Provider；
• 在Java中使用高級別的加解密算法，比如AES使用256bit密鑰、ECC使用Secp256r1等需要更新JRE的security policy文件，否則會報類似“Illegal key size or default parameters”這樣的錯誤。具體怎樣更換policy文件，可以參考這里
• 實際項目開發過程中，可能發現有傳遞給Java的公鑰不是完整的X.509 SubjectPublicKeyInfo，比如只傳遞了一個65字節的ECPoint過來，這種情況可以跟對方溝通清楚所使用的Algorithm以及NamedCurve，補全DER數據后，再使用Java Security庫解析。

JDK 1.7
依賴：org.bouncycastle:bcprov-jdk15on:1.59

import com.sun.jersey.core.util.Base64;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.SignatureException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import org.apache.commons.codec.binary.Hex;
import org.apache.commons.codec.binary.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ECCUtils {

  private static final Logger LOGGER = LoggerFactory.getLogger(ECCUtils.class);
  private static final String PROVIDER = "BC";

  private static final byte[] PUB_KEY_TL= new byte[26];

  static {
    Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());

    try {
      KeyPair keyPair = genKeyPair();
      PublicKey publicKeyExample = keyPair.getPublic();
      System.arraycopy(publicKeyExample.getEncoded(), 0, PUB_KEY_TL, 0, 26);
    } catch (Exception e) {
      LOGGER.error("無法初始化算法", e);
    }
  }

  public static KeyPair genKeyPair() throws NoSuchAlgorithmException, NoSuchProviderException {
    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC", PROVIDER);
    keyPairGenerator.initialize(256, new SecureRandom());
    return keyPairGenerator.generateKeyPair();
  }

  public static String encodePublicKey(PublicKey publicKey) {
    return StringUtils.newStringUtf8(Base64.encode(publicKey.getEncoded()));
  }

  public static PublicKey decodePublicKey(String keyStr)
      throws NoSuchProviderException, NoSuchAlgorithmException {
    byte[] keyBytes = getPubKeyTLV(keyStr);

    X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
    KeyFactory keyFactory = KeyFactory.getInstance("EC", PROVIDER);
    try {
      return keyFactory.generatePublic(keySpec);
    } catch (InvalidKeySpecException e) {
      LOGGER.error("無效的ECC公鑰", e);
      return null;
    }
  }

  private static byte[] getPubKeyTLV(String keyStr) {
    byte[] keyBytes = Base64.decode(StringUtils.getBytesUtf8(keyStr));

    if(keyBytes.length == 65) {
      byte[] tlv = new byte[91];
      System.arraycopy(PUB_KEY_TL, 0, tlv, 0, 26);
      System.arraycopy(keyBytes, 0, tlv, 26, 65);
      return tlv;
    }

    return keyBytes;
  }

  public static String encodePrivateKey(PrivateKey privateKey) {
    return StringUtils.newStringUtf8(Base64.encode(privateKey.getEncoded()));
  }

  public static PrivateKey decodePrivateKey(String keyStr)
      throws NoSuchProviderException, NoSuchAlgorithmException {
    byte[] keyBytes = Base64.decode(StringUtils.getBytesUtf8(keyStr));
    PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
    KeyFactory keyFactory = KeyFactory.getInstance("EC", PROVIDER);
    try {
      return keyFactory.generatePrivate(keySpec);
    } catch (InvalidKeySpecException e) {
      LOGGER.error("無效的ECC私鑰", e);
      return null;
    }
  }

  public static byte[] encrypt(byte[] content, PublicKey publicKey)
      throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException, NoSuchProviderException {
    Cipher cipher = Cipher.getInstance("ECIES", PROVIDER);
    cipher.init(Cipher.ENCRYPT_MODE, publicKey);
    return cipher.doFinal(content);
  }

  public static byte[] decrypt(byte[] content, PrivateKey privateKey)
      throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException, NoSuchProviderException {
    Cipher cipher = Cipher.getInstance("ECIES", PROVIDER);
    cipher.init(Cipher.DECRYPT_MODE, privateKey);
    return cipher.doFinal(content);
  }

  public static byte[] signature(byte[] content, PrivateKey privateKey)
      throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
    Signature signature = Signature.getInstance("SHA256withECDSA");
    signature.initSign(privateKey);
    signature.update(content);
    return signature.sign();
  }

  public static boolean verify(byte[] content, byte[] sign, PublicKey publicKey)
      throws NoSuchAlgorithmException, InvalidKeyException {
    Signature signature = Signature.getInstance("SHA256withECDSA");
    signature.initVerify(publicKey);
    try {
      signature.update(content);
      return signature.verify(sign);
    } catch (SignatureException e) {
      LOGGER.warn("無效的簽名", e);
      return false;
    }

  }
}

總結：密碼學相關的標准、協議很多，原理往往需要一些數學基礎。想要程序馬上work起來可能容易，想要搞清楚原理，需要花些時間才行。