API对接文档

Appearance

On this page

数据加密规则 ​

加密算法说明 ​

  1. 双方采用3DES对称加密方式。
  2. 指定加密的运算模式ECB。
  3. 设置加密算法的填充模式PKCS5。
  4. 提供字节为24位的加密Key。
  5. 加密结果输出为base64编码

PHP版本加解密示例代码 ​

php
<?php
/**
 * php版本TripleDES加密代码
 */


 class TripleDES{

    public function encrypt($key,$stringData){
        return base64_encode(openssl_encrypt($stringData , 'DES-EDE3' , $key , OPENSSL_RAW_DATA));
    }

    public function decrpyt($key,$encryptData){
        return openssl_decrypt(base64_decode($encryptData), 'DES-EDE3', $key, OPENSSL_RAW_DATA);
    }

 }


 $encryptKey = 'KNsRbpUtjpE3gzY3bOBIPlAhxbiV8etF';
 $plainText = "FC3AEEB1502D0A80";

 $threeDes = new TripleDES();

 echo "plain text:".$plainText."\n";
 $encryptResult = $threeDes->encrypt($encryptKey,$plainText);
 echo "encrypt result:".$encryptResult."\n";
 echo "--------------divider line-------------------\n";
 echo "decrypt result:".$threeDes->decrpyt($encryptKey,$encryptResult)."\n";

?>

java版本加密示例代码 ​

java
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;


public class TripleDES {

    public static void main(String[] args) throws Exception {

        String encryptKey = "KNsRbpUtjpE3gzY3bOBIPlAhxbiV8etF";
        String plainText = "FC3AEEB1502D0A80";
        System.out.println("plain text string:" + plainText);
        String encryptResult = new TripleDES().encrypt(plainText,encryptKey);
        System.out.println("encrypt result:" + encryptResult);       
    }


    public String encrypt(String text, String encodeKey) throws Exception {
        try{
            final byte[] digestOfPassword = encodeKey.substring(0, 24).getBytes("utf-8");
            final SecretKey key = new SecretKeySpec(digestOfPassword,"DESede");
            final Cipher cipher = Cipher.getInstance("DESede/ECB/pkcs5padding");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            final byte[] plainTextBytes = text.getBytes("utf-8");
            final byte[] cipherText = cipher.doFinal(plainTextBytes);
            return Base64.getEncoder().encodeToString(cipherText);
        }catch(Exception e){
            return null;
        }
    }
}

golang版本加密示例代码 ​

go
package main

import (
	"bytes"
	"crypto/des"
	"encoding/base64"
	"errors"
	"fmt"
)

//ECB PKCS5Padding
func PKCS5Padding(ciphertext []byte, blockSize int) []byte {
	padding := blockSize - len(ciphertext)%blockSize
	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
	return append(ciphertext, padtext...)
}

//ECB PKCS5Unpadding
func PKCS5Unpadding(origData []byte) []byte {
	length := len(origData)
	unpadding := int(origData[length-1])
	return origData[:(length - unpadding)]
}

//Des encryption
func encrypt(origData, key []byte) ([]byte, error) {
	if len(origData) < 1 || len(key) < 1 {
		return nil, errors.New("wrong data or key")
	}
	block, err := des.NewCipher(key)
	if err != nil {
		return nil, err
	}
	bs := block.BlockSize()
	if len(origData)%bs != 0 {
		return nil, errors.New("wrong padding")
	}
	out := make([]byte, len(origData))
	dst := out
	for len(origData) > 0 {
		block.Encrypt(dst, origData[:bs])
		origData = origData[bs:]
		dst = dst[bs:]
	}
	return out, nil
}

//Des Decrypt
func decrypt(crypted, key []byte) ([]byte, error) {
	if len(crypted) < 1 || len(key) < 1 {
		return nil, errors.New("wrong data or key")
	}
	block, err := des.NewCipher(key)
	if err != nil {
		return nil, err
	}
	out := make([]byte, len(crypted))
	dst := out
	bs := block.BlockSize()
	if len(crypted)%bs != 0 {
		return nil, errors.New("wrong crypted size")
	}

	for len(crypted) > 0 {
		block.Decrypt(dst, crypted[:bs])
		crypted = crypted[bs:]
		dst = dst[bs:]
	}

	return out, nil
}

//[golang ECB 3DES Encrypt]
func TripleEcbDesEncrypt(origData, key []byte) (string, error) {
	tkey := make([]byte, 24, 24)
	copy(tkey, key)
	k1 := tkey[:8]
	k2 := tkey[8:16]
	k3 := tkey[16:]

	block, err := des.NewCipher(k1)
	if err != nil {
		return "", nil
	}
	bs := block.BlockSize()
	origData = PKCS5Padding(origData, bs)

	buf1, err := encrypt(origData, k1)
	if err != nil {
		return "", nil
	}
	buf2, err := decrypt(buf1, k2)
	if err != nil {
		return "", nil
	}
	out, err := encrypt(buf2, k3)
	if err != nil {
		return "", nil
	}
	encryptString := base64.StdEncoding.EncodeToString(out)
	return encryptString, nil
}

func main() {

	//加密秘钥
	encryptKey := []byte("KNsRbpUtjpE3gzY3bOBIPlAhxbiV8etF")
	//加密字符串源数据
	plainText := []byte("FC3AEEB1502D0A80")
	fmt.Printf("plain text string: %s\n", plainText)
	//加密后数据
	encryptString, _ := TripleEcbDesEncrypt(plainText, encryptKey)
	fmt.Printf("encrypt result: %s\n", encryptString)
}