SM2加密解决java与iOS端加解密不配套问题

我就是我 2023-01-12 10:11 121阅读 0赞

### SM2加密解决java与iOS端加解密不配套问题 ###

*  问题描述
 *   *  问题判定
     *  代码
     *  声明

# 问题描述 #

使用java开发的SM2加解密，由java层生成SM2公私钥，iOS、Android(因和java层一致，暂忽略)层使用公钥做加密，java层做解密。

1.  java生成的公私钥在iOS和java层单独做加解密均可用。
2.  iOS层加密结果java层无法解密

## 问题判定 ##

SM2非对称加密的结果由C1,C2,C3三部分组成。其中C1是生成随机数的计算出的椭圆曲线点，C2是密文数据，C3是SM3的摘要值。最开始的国密标准的结果是按C1C2C3顺序的，新标准的是按C1C3C2顺序存放的。java层SM2结果是C1C2C3，iOS（C）的结果是C1C3C2。

以下调整java层SM2代码为C1C3C2。

## 代码 ##

使用方法：使用方法参考下方SM2Util中main方法。  
使用jar包为：bcprov-jdk15on-1.65.jar  
maven引入：

<sm2.version>1.65</sm2.version>
    			
                <dependency>
                    <groupId>org.bouncycastle</groupId>
                    <artifactId>bcprov-jdk15on</artifactId>
                    <version>${sm2.version}</version>
                </dependency>

SM2公私钥实体类SM2KeyPair ：

/**
     *  SM2公私钥实体类
     */
    public class SM2KeyPair {
        
    
        /** 公钥 */
        private String publicKeyStr;
    
        /** 私钥 */
        private String privateKeyStr;
    
        SM2KeyPair(String publicKeyStr, String privateKeyStr) {
        
            this.publicKeyStr = publicKeyStr;
            this.privateKeyStr = privateKeyStr;
        }
    
        public String getPublicKeyStr() {
        
            return publicKeyStr;
        }
    
        public String getPrivateKeyStr() {
        
            return privateKeyStr;
        }
    
    }

SM2加减密实现类ZSM2Engine：

import java.io.IOException;
    import java.math.BigInteger;
    import java.security.SecureRandom;
    import org.bouncycastle.asn1.ASN1EncodableVector;
    import org.bouncycastle.asn1.ASN1InputStream;
    import org.bouncycastle.asn1.ASN1Integer;
    import org.bouncycastle.asn1.ASN1OctetString;
    import org.bouncycastle.asn1.ASN1Sequence;
    import org.bouncycastle.asn1.DEROctetString;
    import org.bouncycastle.asn1.DERSequence;
    import org.bouncycastle.crypto.CipherParameters;
    import org.bouncycastle.crypto.Digest;
    import org.bouncycastle.crypto.InvalidCipherTextException;
    import org.bouncycastle.crypto.digests.SM3Digest;
    import org.bouncycastle.crypto.params.*;
    import org.bouncycastle.math.ec.ECFieldElement;
    import org.bouncycastle.math.ec.ECMultiplier;
    import org.bouncycastle.math.ec.ECPoint;
    import org.bouncycastle.math.ec.FixedPointCombMultiplier;
    import org.bouncycastle.util.Arrays;
    import org.bouncycastle.util.BigIntegers;
    import org.bouncycastle.util.Memoable;
    import org.bouncycastle.util.Pack;
    /**
     * SM2加解密实现类
     */
    public class ZSM2Engine {
        
    
        public enum Mode {
        
            C1C2C3, C1C3C2;
        }
    
        private final Digest digest;
        private final Mode mode;
    
        private boolean forEncryption;
        private ECKeyParameters ecKey;
        private ECDomainParameters ecParams;
        private int curveLength;
        private SecureRandom random;
        /***
         * 默认采用国标：C1||C3||C2
         */
        public ZSM2Engine() {
        
            this(new SM3Digest(), Mode.C1C3C2);
        }
    
        public ZSM2Engine(Mode mode) {
        
            this(new SM3Digest(), mode);
        }
    
        public ZSM2Engine(Digest digest) {
        
            this(digest, Mode.C1C2C3);
        }
    
        public ZSM2Engine(Digest digest, Mode mode) {
        
            if (mode == null) {
        
                throw new IllegalArgumentException("mode cannot be NULL");
            }
            this.digest = digest;
            this.mode = mode;
        }
    
        /**
         * 初始化
         * @param forEncryption true-公钥加密, false-私钥解密
         * @param param 密码参数，从中获取公或私钥、及椭圆曲线相关参数
         */
        public void init(boolean forEncryption, CipherParameters param) {
        
            this.forEncryption = forEncryption;
    
            if (forEncryption) {
        
                ParametersWithRandom rParam = (ParametersWithRandom) param;
    
                ecKey = (ECKeyParameters) rParam.getParameters();
                ecParams = ecKey.getParameters();
    
                ECPoint s = ((ECPublicKeyParameters) ecKey).getQ().multiply(ecParams.getH());
                if (s.isInfinity()) {
        
                    throw new IllegalArgumentException("invalid key: [h]Q at infinity");
                }
    
                random = rParam.getRandom();
            } else {
        
                ecKey = (ECKeyParameters) param;
                ecParams = ecKey.getParameters();
            }
    
            curveLength = (ecParams.getCurve().getFieldSize() + 7) / 8;
        }
    
        /**
         * 进行加密、或解密
         * @param in
         * @param inOff
         * @param inLen
         * @return
         * @throws InvalidCipherTextException
         */
        public byte[] processBlock(
                byte[] in,
                int inOff,
                int inLen)
                throws IOException, InvalidCipherTextException {
        
            if (forEncryption) {
        
                return encrypt(in, inOff, inLen);
            } else {
        
                return decrypt(in, inOff, inLen);
            }
        }
    
        public int getOutputSize(int inputLen) {
        
            return (1 + 2 * curveLength) + inputLen + digest.getDigestSize();
        }
    
        protected ECMultiplier createBasePointMultiplier() {
        
            return new FixedPointCombMultiplier();
        }
    
        private byte[] encrypt(byte[] in, int inOff, int inLen)
                throws IOException {
        
            byte[] c2 = new byte[inLen];
    
            System.arraycopy(in, inOff, c2, 0, c2.length);
    
            ECMultiplier multiplier = createBasePointMultiplier();
    
            ECPoint c1P;
            ECPoint kPB;
            do {
        
                BigInteger k = nextK();
    
                c1P = multiplier.multiply(ecParams.getG(), k).normalize();
                // c1 = c1P.getEncoded(false);
    
                kPB = ((ECPublicKeyParameters) ecKey).getQ().multiply(k).normalize();
    
                kdf(digest, kPB, c2);
            }
    
            while (notEncrypted(c2, in, inOff));
    
            byte[] c3 = new byte[digest.getDigestSize()];
    
            addFieldElement(digest, kPB.getAffineXCoord());
            digest.update(in, inOff, inLen);
            addFieldElement(digest, kPB.getAffineYCoord());
    
            digest.doFinal(c3, 0);
    
            switch (mode) {
        
                case C1C3C2:
                    // 修复 ANS.1 编码
                    final ASN1EncodableVector vector = new ASN1EncodableVector();
                    vector.add(new ASN1Integer(c1P.getXCoord().toBigInteger()));
                    vector.add(new ASN1Integer(c1P.getYCoord().toBigInteger()));
                    vector.add(new DEROctetString(c3));
                    vector.add(new DEROctetString(c2));
                    return new DERSequence(vector).getEncoded();
                default:
                    byte[] c1 = c1P.getEncoded(false);
                    return Arrays.concatenate(c1, c2, c3);
            }
        }
    
        private byte[] decrypt(byte[] in, int inOff, int inLen)
                throws InvalidCipherTextException, IOException {
        
    
            ECPoint c1P; // = ecParams.getCurve().decodePoint(c1);
            byte[] inHash ;
            byte[] inCipherData;
    
            if (mode == Mode.C1C3C2) {
        
                //修复 ASN1
                ASN1InputStream inputStream = new ASN1InputStream(in);
                ASN1Sequence seq = (ASN1Sequence) inputStream.readObject();
                if (seq.size() != 4){
        
                    throw new InvalidCipherTextException("invalid cipher text");
                }
                int index = 0;
    
                // C1 == XCoordinate 、YCoordinate
                BigInteger x = ((ASN1Integer) seq.getObjectAt(index ++)).getPositiveValue();
                // YCoordinate
                BigInteger y = ((ASN1Integer) seq.getObjectAt(index ++)).getPositiveValue();
    
                // XCoord 、YCoord ==> CEPoint (C1)
                c1P = ecParams.getCurve().createPoint(x, y);
    
                // HASH (C3)
                inHash = ((ASN1OctetString)seq.getObjectAt(index ++)).getOctets();
    
                // CipherText (C2)
                inCipherData = ((ASN1OctetString)seq.getObjectAt(index)).getOctets();
            } else {
        
                // C1
                byte[] c1 = new byte[curveLength * 2 + 1];
                System.arraycopy(in, inOff, c1, 0, c1.length);
                c1P = ecParams.getCurve().decodePoint(c1);
    
                // C2 == inCipherData
                int digestSize = this.digest.getDigestSize();
                inCipherData = new byte[inLen - c1.length - digestSize];
                System.arraycopy(in, inOff + c1.length, inCipherData, 0, inCipherData.length);
    
                // C3 == Hash
                inHash = new byte[digestSize];
                System.arraycopy(in, inOff + c1.length + inCipherData.length, inHash, 0, inHash.length);
            }
    
            // 解密 ==> inCipherData;
            ECPoint s = c1P.multiply(ecParams.getH());
            if (s.isInfinity())
            {
        
                throw new InvalidCipherTextException("[h]C1 at infinity");
            }
            c1P = c1P.multiply(((ECPrivateKeyParameters)ecKey).getD()).normalize();
            kdf(digest, c1P, inCipherData);
    
            // 动态计算已解密的明文的摘要并比较
            byte[] cipherDigest = new byte[digest.getDigestSize()];
    
            addFieldElement(digest, c1P.getAffineXCoord());
            digest.update(inCipherData, 0, inCipherData.length);
            addFieldElement(digest, c1P.getAffineYCoord());
    
            digest.doFinal(cipherDigest, 0);
    
            int check = 0;
            if (mode == Mode.C1C3C2)
            {
        
                for (int i = 0; i != cipherDigest.length; i++) {
        
                    check |= cipherDigest[i] ^ inHash[i];
                }
            } else {
        
                for (int i = 0; i != cipherDigest.length; i++) {
        
                    check |= cipherDigest[i] ^ inHash[i];
                }
            }
    
            // Arrays.fill(c1, (byte)0);
            Arrays.fill(cipherDigest, (byte)0);
    
            if (check != 0)
            {
        
                Arrays.fill(inCipherData, (byte)0);
                throw new InvalidCipherTextException("invalid cipher text");
            }
    
            // return c2;
            return inCipherData;
        }
    
        private boolean notEncrypted(byte[] encData, byte[] in, int inOff) {
        
            for (int i = 0; i != encData.length; i++) {
        
                if (encData[i] != in[inOff + i]) {
        
                    return false;
                }
            }
    
            return true;
        }
    
        private void kdf(Digest digest, ECPoint c1, byte[] encData) {
        
            int digestSize = digest.getDigestSize();
            byte[] buf = new byte[Math.max(4, digestSize)];
            int off = 0;
    
            Memoable memo = null;
            Memoable copy = null;
    
            if (digest instanceof Memoable) {
        
                addFieldElement(digest, c1.getAffineXCoord());
                addFieldElement(digest, c1.getAffineYCoord());
                memo = (Memoable) digest;
                copy = memo.copy();
            }
    
            int ct = 0;
    
            while (off < encData.length) {
        
                if (memo != null) {
        
                    memo.reset(copy);
                } else {
        
                    addFieldElement(digest, c1.getAffineXCoord());
                    addFieldElement(digest, c1.getAffineYCoord());
                }
    
                Pack.intToBigEndian(++ct, buf, 0);
                digest.update(buf, 0, 4);
                digest.doFinal(buf, 0);
    
                int xorLen = Math.min(digestSize, encData.length - off);
                xor(encData, buf, off, xorLen);
                off += xorLen;
            }
        }
    
        private void xor(byte[] data, byte[] kdfOut, int dOff, int dRemaining) {
        
            for (int i = 0; i != dRemaining; i++) {
        
                data[dOff + i] ^= kdfOut[i];
            }
        }
    
        private BigInteger nextK() {
        
            int qBitLength = ecParams.getN().bitLength();
    
            BigInteger k;
            do {
        
                k = BigIntegers.createRandomBigInteger(qBitLength, random);
            }
            while (k.equals(BigIntegers.ZERO) || k.compareTo(ecParams.getN()) >= 0);
    
            return k;
        }
    
        private void addFieldElement(Digest digest, ECFieldElement v) {
        
            byte[] p = BigIntegers.asUnsignedByteArray(curveLength, v.toBigInteger());
    
            digest.update(p, 0, p.length);
        }
    }

SM2加减密工具类SM2Util ：

import java.io.IOException;
    import java.math.BigInteger;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import org.bouncycastle.asn1.gm.GMNamedCurves;
    import org.bouncycastle.asn1.x9.X9ECParameters;
    import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
    import org.bouncycastle.crypto.InvalidCipherTextException;
    import org.bouncycastle.crypto.digests.SHA256Digest;
    import org.bouncycastle.crypto.digests.ShortenedDigest;
    import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
    import org.bouncycastle.crypto.params.*;
    import org.bouncycastle.jce.spec.ECParameterSpec;
    import org.bouncycastle.math.ec.ECCurve;
    import org.bouncycastle.math.ec.ECPoint;
    import org.bouncycastle.util.encoders.Hex;
    import java.util.Base64;
    /**
     *   SM2的加解密工具类
     */
    public class SM2Util {
        
        private static X9ECParameters x9ECParameters = GMNamedCurves.getByName("sm2p256v1");
        private static ECDomainParameters ecDomainParameters = new ECDomainParameters(x9ECParameters.getCurve(), x9ECParameters.getG(), x9ECParameters.getN());
        private static ECParameterSpec ecParameterSpec = new ECParameterSpec(x9ECParameters.getCurve(), x9ECParameters.getG(), x9ECParameters.getN());
        /** 素数p */
        private static final BigInteger p = new BigInteger("FFFFFFFE" + "FFFFFFFF"
                + "FFFFFFFF" + "FFFFFFFF" + "FFFFFFFF" + "00000000" + "FFFFFFFF"
                + "FFFFFFFF", 16);
    
        /** 系数a */
        private static final BigInteger a = new BigInteger("FFFFFFFE" + "FFFFFFFF"
                + "FFFFFFFF" + "FFFFFFFF" + "FFFFFFFF" + "00000000" + "FFFFFFFF"
                + "FFFFFFFC", 16);
    
        /** 系数b */
        private static final BigInteger b = new BigInteger("28E9FA9E" + "9D9F5E34"
                + "4D5A9E4B" + "CF6509A7" + "F39789F5" + "15AB8F92" + "DDBCBD41"
                + "4D940E93", 16);
    
        /** 坐标x */
        private static final BigInteger xg = new BigInteger("32C4AE2C" + "1F198119"
                + "5F990446" + "6A39C994" + "8FE30BBF" + "F2660BE1" + "715A4589"
                + "334C74C7", 16);
    
        /** 坐标y */
        private static final BigInteger yg = new BigInteger("BC3736A2" + "F4F6779C"
                + "59BDCEE3" + "6B692153" + "D0A9877C" + "C62A4740" + "02DF32E5"
                + "2139F0A0", 16);
    
        /** 基点G, G=(xg,yg),其介记为n */
        private static final BigInteger n = new BigInteger("FFFFFFFE" + "FFFFFFFF"
                + "FFFFFFFF" + "FFFFFFFF" + "7203DF6B" + "21C6052B" + "53BBF409"
                + "39D54123", 16);
        public static SecureRandom random = new SecureRandom();
        public static ECDomainParameters ecc_bc_spec;
        public static ECCurve.Fp curve;
        public static ECPoint G;
        public static boolean debug = false;
    
        public SM2Util() {
        
    
        }
        static{
        
            curve = new ECCurve.Fp(p, // q
                    a, // a
                    b); // b
            G = curve.createPoint(xg, yg);
            ecc_bc_spec = new ECDomainParameters(curve, G, n);
        }
    
        /**
         * 公钥校验
         * @param publicKey 公钥
         * @return boolean true或false
         */
        private static boolean checkPublicKey(ECPoint publicKey) {
        
            if (!publicKey.isInfinity()) {
        
                BigInteger x = publicKey.getXCoord().toBigInteger();
                BigInteger y = publicKey.getYCoord().toBigInteger();
                if (between(x, new BigInteger("0"), p) && between(y, new BigInteger("0"), p)) {
        
                    BigInteger xResult = x.pow(3).add(a.multiply(x)).add(b).mod(p);
                    System.out.println("xResult: " + xResult.toString());
                    BigInteger yResult = y.pow(2).mod(p);
                    System.out.println("yResult: " + yResult.toString());
                    if (yResult.equals(xResult) && publicKey.multiply(n).isInfinity()) {
        
                        return true;
                    }
                }
                return false;
            } else {
        
                return false;
            }
        }
        /**
         * 获得公私钥对
         * @return
         */
        public static SM2KeyPair generateKeyPair() {
        
    
            //生成密钥对
            ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator();
            try {
        
                keyPairGenerator.init(new ECKeyGenerationParameters(ecc_bc_spec, SecureRandom.getInstance("SHA1PRNG")));
            } catch (NoSuchAlgorithmException e) {
        
                e.printStackTrace();
            }
            AsymmetricCipherKeyPair asymmetricCipherKeyPair = keyPairGenerator.generateKeyPair();
    
            //私钥，16进制格式，自己保存，格式如a2081b5b81fbea0b6b973a3ab6dbbbc65b1164488bf22d8ae2ff0b8260f64853
            BigInteger privatekey = ((ECPrivateKeyParameters) asymmetricCipherKeyPair.getPrivate()).getD();
            //公钥，16进制格式，发给前端，格式如04813d4d97ad31bd9d18d785f337f683233099d5abed09cb397152d50ac28cc0ba43711960e811d90453db5f5a9518d660858a8d0c57e359a8bf83427760ebcbba
            ECPoint ecPoint = ((ECPublicKeyParameters) asymmetricCipherKeyPair.getPublic()).getQ();
            String privateKeyHex = privatekey.toString(16);
            String publicKeyHex = Hex.toHexString(ecPoint.getEncoded(false));
            SM2KeyPair keyPair = new SM2KeyPair(publicKeyHex, privateKeyHex);
    
    
            if (checkPublicKey(ecPoint)) {
        
                System.out.println("generate key successfully");
                return keyPair;
            } else {
        
                System.err.println("generate key failed");
                return null;
            }
        }
        /**
         * 加密
         * @param input 待加密消息M
         * @param publicKeyStr 公钥字符串
         * @return byte[] 加密后的字节数组
         */
        public static String encrypt(String input, String publicKeyStr) {
        
            String encBase64Str = null;
            try {
        
              byte buffer[] = Hex.decode(publicKeyStr);
                ECPoint ecPointPub = x9ECParameters.getCurve().decodePoint(buffer);
                ECPublicKeyParameters publicKeyParameters = new ECPublicKeyParameters(ecPointPub,ecDomainParameters);
                byte[] plaintextBytes = input.getBytes();
                ZSM2Engine sm2EngineEnc = new ZSM2Engine();
                sm2EngineEnc.init(true, new ParametersWithRandom(publicKeyParameters, new SecureRandom()));
    
                byte[] encBytes = null;
                encBytes = sm2EngineEnc.processBlock(plaintextBytes, 0, plaintextBytes.length);
    
                encBase64Str = new String(Base64.getEncoder().encode(encBytes));
            }catch (Exception e){
        
                return null;
            }
            return encBase64Str;
        }
    
        public static String decrypt(String encryptData, String privateKeyStr) {
        
            String result = null;
            try {
        
                byte[] encryptByte = Base64.getDecoder().decode(encryptData);
                result = decrypt(encryptByte,privateKeyStr);
            }catch (Exception e){
        
            }
            return result;
        }
    
        public static String decrypt(byte[] encryptData, String privateKeyStr) {
        
            String data = null;
            try {
        
                BigInteger privateKeyD = new BigInteger(privateKeyStr, 16);
                ECPrivateKeyParameters privateKeyParameters = new ECPrivateKeyParameters(privateKeyD, ecDomainParameters);
                //解密-------------------------------------------------------------------------------------------------------
    
                //用私钥解密
                ZSM2Engine sm2EngineDec = new ZSM2Engine();
                sm2EngineDec.init(false, privateKeyParameters);
                byte[] arrayOfBytes = null;
                try {
        
                    arrayOfBytes = sm2EngineDec.processBlock(encryptData, 0, encryptData.length);
                } catch (IOException e) {
        
                    e.printStackTrace();
                } catch (InvalidCipherTextException e) {
        
                    e.printStackTrace();
                }
                //得到明文：SM2 Encryption Test
                data = new String(arrayOfBytes);
                return data;
            }catch (Exception e){
        
                return data;
            }
        }
    
        private static byte[] calculateHash(BigInteger x2, byte[] M, BigInteger y2) {
        
            ShortenedDigest digest = new ShortenedDigest(new SHA256Digest(), 20);
            byte[] buf = x2.toByteArray();
            digest.update(buf, 0, buf.length);
            digest.update(M, 0, M.length);
            buf = y2.toByteArray();
            digest.update(buf, 0, buf.length);
    
            buf = new byte[20];
            digest.doFinal(buf, 0);
            return buf;
        }
    
        private static boolean between(BigInteger param, BigInteger min, BigInteger max) {
        
            if (param.compareTo(min) >= 0 && param.compareTo(max) < 0) {
        
                return true;
            } else {
        
                return false;
            }
        }
        public static String byteArrayToHexString(byte[] a) {
        
            StringBuilder sb = new StringBuilder(a.length * 2);
            for (byte b : a) {
        
                sb.append(String.format("%02X", b));
            }
            return sb.toString();
        }
    
        /** 元消息串 */
        private static String M = "{\"sessionId\":\"123456789\",\"customerNo\":\"12345678\",\"requestContent\":\"你好\",\"requestType\":\"text\"}";
    
        public static void main(String[] args) {
        
            SM2KeyPair keyPair = SM2Util.generateKeyPair();
            String publicKeyNativeFull = keyPair.getPublicKeyStr();
            System.out.println("publicKeyNativeFull:" + publicKeyNativeFull);
            String privateKeyNativeFull =  keyPair.getPrivateKeyStr();
            System.out.println("privateKeyNativeFull:" + privateKeyNativeFull);
    
            String test  = SM2Util.encrypt(M,keyPair.getPublicKeyStr());
            System.out.println("data is:"+test);
            String resultData1 = SM2Util.decrypt(test,keyPair.getPrivateKeyStr());
            System.out.println("resultData:" + resultData1);
        }
    }

## 声明 ##

以上代码由部分网友及海哥提供。