SM2加解密：c1c3c2与Asn1格式

JAVA中的提供的第三方jar包(比如BouncyCastle), 对于SM2加密的大都是c1c2c3格式。在Java体系内互相认证，问题不大，但如果与其他语言对接时, 就需要按照最新的国家标准, 将其转换成c1c3c2的asn1格式。

BouncyCastle 提供了一些类辅助，例如：

private static final int C1_LEN = 65;
private static final int C3_LEN = 32;
/**
     * 将c1c3c2转成标准的ASN1格式
     *
     * @param c1c3c2
     * @return
     * @throws IOException
     */
    public static byte[] changeC1C3C2ToAsn1(byte[] c1c3c2) throws IOException {
        byte[] c1 = Arrays.copyOfRange(c1c3c2, 0, C1_LEN);
        byte[] c3 = Arrays.copyOfRange(c1c3c2, C1_LEN, C1_LEN + C3_LEN);
        byte[] c2 = Arrays.copyOfRange(c1c3c2, C1_LEN + C3_LEN, c1c3c2.length);
        byte[] c1X = Arrays.copyOfRange(c1, 1, 33);
        byte[] c1Y = Arrays.copyOfRange(c1, 33, 65);
        ASN1Integer x = new ASN1Integer(c1X);
        ASN1Integer y = new ASN1Integer(c1Y);
        DEROctetString derDig = new DEROctetString(c3);
        DEROctetString derEnc = new DEROctetString(c2);
        ASN1EncodableVector v = new ASN1EncodableVector();
        v.add(x);
        v.add(y);
        v.add(derDig);
        v.add(derEnc);
        DERSequence seq = new DERSequence(v);
        return seq.getEncoded();
    }

    /**
     * 将ASN1格式转成c1c3c2
     *
     * @param asn1
     * @return
     * @throws IOException
     */
    public static byte[] changeAsn1ToC1C3C2(byte[] asn1) throws IOException {
        ASN1InputStream aIn = new ASN1InputStream(asn1);
        ASN1Sequence seq = (ASN1Sequence) aIn.readObject();
        BigInteger x = ASN1Integer.getInstance(seq.getObjectAt(0)).getValue();
        BigInteger y = ASN1Integer.getInstance(seq.getObjectAt(1)).getValue();
        byte[] c3 = ASN1OctetString.getInstance(seq.getObjectAt(2)).getOctets();
        byte[] c2 = ASN1OctetString.getInstance(seq.getObjectAt(3)).getOctets();
        // 不压缩
        ECPoint c1Point = x9ECParameters.getCurve().createPoint(x, y, false);
        byte[] c1 = c1Point.getEncoded();

        return ByteUtils.join(c1, c3, c2);
    }

但 BouncyCastle 各版本可能存在冲突，也不希望为了一个转换引入第三方包。这里我写了一个基于JDK的c1c3c2和asn1的转换。

其实，了解清楚asn1的格式就不难转换了：

ASN.1 = 48,len-bts,c1_asn1,c3_asn1(4,length_c3,c3),c2_asn1(4,len-bts,c2)
说明:
48：SEQUENCE(0x10) | CONSTRUCTED(0x20) 说明是有预定格式的序列
len-bts：数据内容的长度，就是后面字节长度，可能是多个字节(长度字节大小,长度字节)
c1_asn1：c1的Asn1格式(2,len_x,[0],byte_x,2,len_y,[0],byte_y)
c2_asn1：len-bts是c2的数据内容的长度 ，可能是多个字节(长度字节大小,长度字节) 

具体代码如下：BigIntegers.java

public final class BigIntegers {
    /**
     * Return the passed in value as an unsigned byte array.
     *
     * @param value value to be converted.
     * @return a byte array without a leading zero byte if present in the signed encoding.
     */
    public static byte[] asUnsignedByteArray(BigInteger value) {
        byte[] bytes = value.toByteArray();

        if (bytes[0] == 0) {
            byte[] tmp = new byte[bytes.length - 1];

            System.arraycopy(bytes, 1, tmp, 0, tmp.length);

            return tmp;
        }

        return bytes;
    }

    /**
     * Return the passed in value as an unsigned byte array.
     *
     * @param value value to be converted.
     * @return a byte array without a leading zero byte if present in the signed encoding.
     */
    public static byte[] asUnsignedByteArray(int length, BigInteger value) {
        byte[] bytes = value.toByteArray();
        if (bytes.length == length) {
            return bytes;
        }

        int start = bytes[0] == 0 ? 1 : 0;
        int count = bytes.length - start;

        if (count > length) {
            throw new IllegalArgumentException("standard length exceeded for value");
        }

        byte[] tmp = new byte[length];
        System.arraycopy(bytes, start, tmp, tmp.length - count, count);
        return tmp;
    }

    public static BigInteger fromUnsignedByteArray(byte[] buf) {
        return new BigInteger(1, buf);
    }

    public static BigInteger fromUnsignedByteArray(byte[] buf, int off, int length) {
        byte[] mag = buf;
        if (off != 0 || length != buf.length) {
            mag = new byte[length];
            System.arraycopy(buf, off, mag, 0, length);
        }
        return new BigInteger(1, mag);
    }
}

Asn1Point.java

/**
 * ASN1
 * 格式: 2,len_x,[0],byte_x,2,len_y,[0],byte_y
 */
public static class Asn1Point {
    private static final byte PREFIX = 2;
    private byte[] x;
    private byte[] y;
    private boolean negativeR;
    private boolean negativeS;

    public static Asn1Point of(byte[] x, byte[] y) {
        Asn1Point asn1 = new Asn1Point();
        asn1.x = x;
        asn1.y = y;
        asn1.negativeR = x[0] < 0;
        asn1.negativeS = y[0] < 0;
        return asn1;
    }

    public static Asn1Point of(byte[] asn1) {
        int lenX = asn1[1];
        int lenY = asn1[lenX + 3];
        int idxX = 2;
        int idxY = asn1.length - lenY;
        byte[] r = new byte[lenX];
        byte[] s = new byte[lenY];
        //获取R
        System.arraycopy(asn1, idxX, r, 0, lenX);
        // 判断第一个是否是正负符号
        if (r[0] == 0 && r[1] < 0) {
            r = Arrays.copyOfRange(r, 1, lenX);
        }
        //获取S
        System.arraycopy(asn1, idxY, s, 0, lenY);
        if (s[0] == 0 && s[1] < 0) {
            s = Arrays.copyOfRange(s, 1, lenY);
        }
        //返回
        return of(r, s);
    }

    public byte[] getX() {
        return x;
    }

    public byte[] getY() {
        return y;
    }

    public byte[] toXY() {
        int lenR = x.length;
        int lenS = y.length;
        byte[] rs = new byte[lenR + lenS];
        //获取R
        System.arraycopy(x, 0, rs, 0, lenR);
        //获取S
        System.arraycopy(y, 0, rs, lenR, lenS);
        return rs;
    }

    public byte[] toAsn1() {
        // 计算长度
        int lenR = x.length;
        int lenS = y.length;
        if (negativeR) {
            lenR += 1;
        }
        if (negativeS) {
            lenS += 1;
        }
        int len = lenR + lenS + 4;

        byte[] asn1 = new byte[len];
        int idx = 0;
        // x
        asn1[idx++] = PREFIX;
        asn1[idx++] = (byte) lenR;
        if (negativeR) {
            asn1[idx++] = 0;
        }
        System.arraycopy(x, 0, asn1, idx, x.length);
        idx += x.length;
        // y
        asn1[idx++] = PREFIX;
        asn1[idx++] = (byte) lenS;
        if (negativeS) {
            asn1[idx++] = 0;
        }
        System.arraycopy(y, 0, asn1, idx, y.length);

        return asn1;
    }
}

EncryptAsn1.java

/**
     * ASN1
     * 格式: 48,len-c1c3c2_asn1,c1_asn1,c3_asn1(4,len,c3),c2_asn1(4,len-bts,c3)
     */
    public static class EncryptAsn1 {
        private static final byte PREFIX = SEQUENCE | CONSTRUCTED; // 48
        private static final byte PREFIX_C = 4;
        /**
         * sm2p256v1的这个固定65。可看GMNamedCurves、ECCurve代码
         * (x9ECParameters.getCurve().getFieldSize() + 7) / 8 * 2 + 1
         */
        private static final int C1_LEN = 65;
        /**
         * new SM3Digest().getDigestSize()
         */
        private static final int C3_LEN = 32;
        private byte[] c1;
        private byte[] c2;
        private byte[] c3;
        private Asn1Point c1Point;

        public static EncryptAsn1 ofC1C2C3(byte[] c1c2c3) {
            EncryptAsn1 asn1 = new EncryptAsn1();

            asn1.c1 = Arrays.copyOfRange(c1c2c3, 0, C1_LEN);
            asn1.c2 = Arrays.copyOfRange(c1c2c3, C1_LEN, c1c2c3.length - C3_LEN);
            asn1.c3 = Arrays.copyOfRange(c1c2c3, c1c2c3.length - C3_LEN, c1c2c3.length);
            asn1.c1Point = Asn1Point.of(getX(asn1.c1), getY(asn1.c1));

            return asn1;
        }

        public static EncryptAsn1 ofC1C3C2(byte[] c1c3c2) {
            EncryptAsn1 asn1 = new EncryptAsn1();

            asn1.c1 = Arrays.copyOfRange(c1c3c2, 0, C1_LEN);
            asn1.c3 = Arrays.copyOfRange(c1c3c2, C1_LEN, C1_LEN + C3_LEN);
            asn1.c2 = Arrays.copyOfRange(c1c3c2, C1_LEN + C3_LEN, c1c3c2.length);
            asn1.c1Point = Asn1Point.of(getX(asn1.c1), getY(asn1.c1));

            return asn1;

        }

        public static EncryptAsn1 ofAsn1(byte[] asn1Bts) {
            EncryptAsn1 asn1 = new EncryptAsn1();

            // 计算c1c3c2Len
            byte[] lenBts = getUnSignedLengthByte(asn1Bts, 1);
            int c1c3c2Len = BigIntegers.fromUnsignedByteArray(lenBts).intValue();

            // 取c1_asn1
            int c1Idx = 1 + lenBts.length;
            if (c1c3c2Len > 127) {
                c1Idx++;
            }
            int c1XLen = asn1Bts[c1Idx + 1];
            int c1YLen = asn1Bts[c1Idx + 2 + c1XLen + 1];
            int c1Len = c1XLen + c1YLen + 4;
            byte[] c1Asn1 = Arrays.copyOfRange(asn1Bts, c1Idx, c1Idx + c1Len);
            asn1.c1Point = Asn1Point.of(c1Asn1);
            asn1.c1 = new byte[C1_LEN];
            asn1.c1[0] = PREFIX_C;
            System.arraycopy(asn1.c1Point.toXY(), 0, asn1.c1, 1, C1_LEN - 1);
            // 取c3
            int c3Idx = c1Idx + c1Len + 2;
            asn1.c3 = Arrays.copyOfRange(asn1Bts, c3Idx, c3Idx + C3_LEN);
            // 取c2
            int c2Idx = c3Idx + C3_LEN + 1;
            byte[] c2LenBts = getUnSignedLengthByte(asn1Bts, c2Idx);
            int c2Len = BigIntegers.fromUnsignedByteArray(c2LenBts).intValue();
            c2Idx += c2LenBts.length;
            if (c2Len > 127) {
                c2Idx++;
            }
            asn1.c2 = Arrays.copyOfRange(asn1Bts, c2Idx, c2Idx + c2Len);

            return asn1;
        }

        public byte[] toC1C2C3() {
            return ByteUtils.join(c1, c2, c3);
        }

        public byte[] toC1C3C2() {
            return ByteUtils.join(c1, c3, c2);
        }

        public byte[] toAsn1() {
            byte[] c1Asn1 = c1Point.toAsn1();
            // 计算长度
            int c1Len = c1Asn1.length;
            int c3Len = c3.length;
            // C2长度字节
            int c2Len = c2.length;
            byte[] c2LenBts = getLengthByte(c2Len);
            // C1C3C2长度字节
            int c1c3c2Len = c1Len + 2 + c3Len + 1 + c2LenBts.length + c2Len;
            byte[] lenBts = getLengthByte(c1c3c2Len);
            //总长度
            int len = 1 + lenBts.length + c1c3c2Len;
            // 拼接
            byte[] asn1 = new byte[len];
            int idx = 0;
            // 前缀
            asn1[idx++] = PREFIX;
            // 长度
            System.arraycopy(lenBts, 0, asn1, idx, lenBts.length);
            idx += lenBts.length;
            // c1
            System.arraycopy(c1Asn1, 0, asn1, idx, c1Len);
            idx += c1Len;
            // c3
            asn1[idx++] = PREFIX_C;
            asn1[idx++] = (byte) c3Len;
            System.arraycopy(c3, 0, asn1, idx, c3Len);
            idx += c3Len;
            // c2
            asn1[idx++] = PREFIX_C;
            System.arraycopy(c2LenBts, 0, asn1, idx, c2LenBts.length);
            idx += c2LenBts.length;
            System.arraycopy(c2, 0, asn1, idx, c2Len);

            return asn1;
        }

        public byte[] getC1() {
            return c1;
        }

        public byte[] getC2() {
            return c2;
        }

        public byte[] getC3() {
            return c3;
        }

        public BigInteger getX() {
            return BigIntegers.fromUnsignedByteArray(c1Point.getX());
        }

        public BigInteger getY() {
            return BigIntegers.fromUnsignedByteArray(c1Point.getY());
        }

        private static byte[] getX(byte[] c1) {
            if (c1.length > 64) {
                return Arrays.copyOfRange(c1, 1, RS_LEN + 1);
            }
            return Arrays.copyOfRange(c1, 0, RS_LEN);

        }

        private static byte[] getY(byte[] c1) {
            if (c1.length > 64) {
                return Arrays.copyOfRange(c1, RS_LEN + 1, c1.length);
            }
            return Arrays.copyOfRange(c1, RS_LEN, c1.length);
        }

        /**
         * 将长度转成字节数组: 字节长度,[Int -> byte[]]
         *
         * @param len
         * @return
         */
        private static byte[] getLengthByte(int len) {
            // 小于127,则没有长度字节
            if (len <= 127) {
                return new byte[]{(byte) len};
            }
            // 大于127,增加长度字节
            byte[] lenC3Bts = BigIntegers.asUnsignedByteArray(BigInteger.valueOf(len));
            byte[] rv = new byte[lenC3Bts.length + 1];
            rv[0] = (byte) (lenC3Bts.length - 128);
            System.arraycopy(lenC3Bts, 0, rv, 1, lenC3Bts.length);

            return rv;

        }
    }

    /**
     * 获取长度字节(不包含统计字节)
     *
     * @param lenBts
     * @return
     */
    private static byte[] getUnSignedLengthByte(byte[] lenBts, int idx) {
        int len = 1;
        if (lenBts[idx] < 0) {
            len = lenBts[idx] + 128;
            idx++;
        }
        return Arrays.copyOfRange(lenBts, idx, idx + len);
    }

调用：

// c1c3c2 -> asn1
byte[] c1c3c2;
byte[] asn1 = EncryptAsn1.ofC1C3C2(rs).toAsn1();
// c1c3c2 -> asn1
byte[] asn1;
byte[] c1c3c2 = EncryptAsn1.ofAsn1(rs).toC1C3C2();
// c1c2c3 -> c1c3c2
byte[] c1c2c3;
byte[] c1c3c2 = EncryptAsn1.ofC1C2C3(rs).toC1C3C2();