deatil / go-cryptobin Goto Github PK

public static TrustedInvoiceContent parse2(FileResultZww fileResult, CipherParameters privateKey) {
        try {
            SM2Engine sm2Engine = new SM2Engine();
            sm2Engine.init(false, privateKey);
            byte[] encryptedKey = LiteBase64.getUrlDecoder().decode(fileResult.getEnvelope());
            byte[] envelopKey = sm2Engine.processBlock(encryptedKey, 0, encryptedKey.length);
            EncEnums encEnums = EncEnums.SM4EBC;
            Cipher cipher = Cipher.getInstance(encEnums.getDesc(), "BC");
            cipher.init(2, new SecretKeySpec(envelopKey, "SM4"));
            CompressEnums compressEnums = CompressEnums.GZIP;
            byte[] encryptedMessage = LiteBase64.getUrlDecoder().decode(fileResult.getLayoutFile());
            byte[] decodeMessage = cipher.doFinal(encryptedMessage);
            TrustedInvoiceContent trustedInvoiceContent = new TrustedInvoiceContent();
            trustedInvoiceContent.setInvoiceContent(LiteCompressUtils.gzipUncompress(decodeMessage));
            return trustedInvoiceContent;
        } catch (Exception var11) {
            throw new RuntimeException(var11);
        }
    }

private byte[] decrypt(byte[] var1, int var2, int var3) throws InvalidCipherTextException {
        byte[] var4 = new byte[this.curveLength * 2 + 1];
        System.arraycopy(var1, var2, var4, 0, var4.length);
        ECPoint var5 = this.ecParams.getCurve().decodePoint(var4);
        ECPoint var6 = var5.multiply(this.ecParams.getH());
        if (var6.isInfinity()) {
            throw new InvalidCipherTextException("[h]C1 at infinity");
        } else {
            var5 = var5.multiply(((ECPrivateKeyParameters)this.ecKey).getD()).normalize();
            int var7 = this.digest.getDigestSize();
            byte[] var8 = new byte[var3 - var4.length - var7];
            if (this.mode == SM2Engine.Mode.C1C3C2) {
                System.arraycopy(var1, var2 + var4.length + var7, var8, 0, var8.length);
            } else {
                System.arraycopy(var1, var2 + var4.length, var8, 0, var8.length);
            }

            this.kdf(this.digest, var5, var8);
            byte[] var9 = new byte[this.digest.getDigestSize()];
            this.addFieldElement(this.digest, var5.getAffineXCoord());
            this.digest.update(var8, 0, var8.length);
            this.addFieldElement(this.digest, var5.getAffineYCoord());
            this.digest.doFinal(var9, 0);
            int var10 = 0;
            int var11;
            if (this.mode == SM2Engine.Mode.C1C3C2) {
                for(var11 = 0; var11 != var9.length; ++var11) {
                    var10 |= var9[var11] ^ var1[var2 + var4.length + var11];
                }
            } else {
                for(var11 = 0; var11 != var9.length; ++var11) {
                    var10 |= var9[var11] ^ var1[var2 + var4.length + var8.length + var11];
                }
            }

            Arrays.fill(var4, (byte)0);
            Arrays.fill(var9, (byte)0);
            if (var10 != 0) {
                Arrays.fill(var8, (byte)0);
                throw new InvalidCipherTextException("invalid cipher text");
            } else {
                return var8;
            }
        }
    }

   private static String instCode = "xxxxxx";  //纳税人识别号
    //企业密码
    private static String password = "xxx";  // 企业密码
    //企业密钥
    private static String privateKeyContent = "-----BEGIN ENCRYPTED PRIVATE KEY-----\n" +
            "xxxxxxxx/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx/\n" +
            "vZxxxxxxxxxXfgDxxxxxxxxxxtjpNIOxxxxxxxxxxxxxxxxxxxxxx/\n" +
            "Nxxxxxxxxxxxxxxxx0K9LaPOsxAxxxxxxxxxxxxxxxxxxxxxKrAr3n\n" +
            "oSMxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxFNBDt8AX\n" +
            "sexxxxxxxxxxxxxnQiLrdwVtxxxxxxxxxxxxxxxxxx/9Uzl//6RbIt\n" +
            "Xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxv==\n" +
            "----END ENCRYPTED PRIVATE KEY-----";

private static String sign(String jsonStr) {
        GovDataSDK.getInstance().init(instCode, privateKeyContent, password, EncryptTpyeEnum.SM4);
        SignedRequest request = GovDataSDK.getInstance().getRequestBuilder().generateSignedPayload(jsonStr);
        return JSON.toJSONString(request);
    }

//AsymmetricCipherEnum：SM2，DigestEnum：SM3

public static DsaSigner createSigner(AsymmetricCipherEnum asymmetricCipherEnum, DigestEnum digestEnum, InputStream privateKeyStream, String password) throws PKCSException, OperatorCreationException, IOException {
        X9ECParameters CURVE_PARAMS;
        switch (asymmetricCipherEnum) {
            **case SM2:
                CURVE_PARAMS = CustomNamedCurves.getByName(asymmetricCipherEnum.getCurveName());**
                switch (digestEnum) {
                    **case SM3:
                        return new Sm2Impl(CURVE_PARAMS, new SM3Digest(), privateKeyStream, password);**
//-------------
public Sm2Impl(X9ECParameters curveParameter, Digest digest, InputStream privateKeyStream, String password) throws IOException, PKCSException, OperatorCreationException {
        Security.addProvider(new BouncyCastleProvider());
        if (digest != null) {
            this.sm2Engine = new SM2Engine(digest);
        } else {
            this.sm2Engine = new SM2Engine();
        }

        this.sm2Signer = new SM2Signer();
        this.privateKeyInit = true;
        this.curve = new ECDomainParameters(curveParameter.getCurve(), curveParameter.getG(), curveParameter.getN(), curveParameter.getH());
        this.halfCurveOrder = curveParameter.getN().shiftRight(1);
        String privateKeyContent = IOUtils.toString(privateKeyStream, Charset.forName("utf-8"));
        PrivateKey privateKey = Pkcs8Utils.parseEncryptedPrivateKey(privateKeyContent, password);
        BCECPrivateKey bcecPrivateKey = (BCECPrivateKey)privateKey;
        BigInteger d = bcecPrivateKey.getD();
        ECPrivateKeyParameters privKey = new ECPrivateKeyParameters(d, this.curve);
        this.sm2Engine.init(false, privKey);
        this.sm2Signer.init(true, privKey);
    }

public static String sm2Sign( String content,String privateKey ){
    try {
        //init privateKey
        BCECPrivateKey bcecPrivateKey = BCUtil.getPrivatekeyFromD(new BigInteger(privateKey,16));
        byte[] sign = BCUtil.signSm3WithSm2(content.getBytes(),USER_ID.getBytes(),bcecPrivateKey);
        return encodeBase64(signRawToAsn1(sign));
    }catch (Exception ex){
        ex.printStackTrace();
        return null;
    }
}

public static byte[] signSm3WithSm2(byte[] msg, byte[] userId, PrivateKey privateKey){
    return rsAsn1ToPlainByteArray(signSm3WithSm2Asn1Rs(msg, userId, privateKey));
}

public static byte[] signSm3WithSm2Asn1Rs(byte[] msg, byte[] userId, PrivateKey privateKey){
    try {
        SM2ParameterSpec parameterSpec = new SM2ParameterSpec(userId);
        Signature signer = Signature.getInstance("SM3withSM2", "BC");
        signer.setParameter(parameterSpec);
        signer.initSign(privateKey, new SecureRandom());
        signer.update(msg, 0, msg.length);
        byte[] sig = signer.sign();
        return sig;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

private static byte[] rsAsn1ToPlainByteArray(byte[] rsDer){
    ASN1Sequence seq = ASN1Sequence.getInstance(rsDer);
    byte[] r = bigIntToFixexLengthBytes(ASN1Integer.getInstance(seq.getObjectAt(0)).getValue());
    byte[] s = bigIntToFixexLengthBytes(ASN1Integer.getInstance(seq.getObjectAt(1)).getValue());
    byte[] result = new byte[RS_LEN * 2];
    System.arraycopy(r, 0, result, 0, r.length);
    System.arraycopy(s, 0, result, RS_LEN, s.length);
    return result;
}

private static byte[] bigIntToFixexLengthBytes(BigInteger rOrS){
    // for sm2p256v1, n is 00fffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123,
    // r and s are the result of mod n, so they should be less than n and have length<=32
    byte[] rs = rOrS.toByteArray();
    if(rs.length == RS_LEN) return rs;
    else if(rs.length == RS_LEN + 1 && rs[0] == 0) return Arrays.copyOfRange(rs, 1, RS_LEN + 1);
    else if(rs.length < RS_LEN) {
        byte[] result = new byte[RS_LEN];
        Arrays.fill(result, (byte)0);
        System.arraycopy(rs, 0, result, RS_LEN - rs.length, rs.length);
        return result;
    } else {
        throw new RuntimeException("err rs: " + Hex.toHexString(rs));
    }
}