js调用Java实现AEC加解密，以及Java的AEC加解密

js调用Java实现AEC加解密，以及Java的AEC加解密

这是js 的AEC创建aec.utils

importClass(android.util.Base64);
importClass(javax.crypto.Cipher);
importClass(javax.crypto.spec.SecretKeySpec);
importClass(java.nio.charset.Charset);
importClass(java.nio.charset.StandardCharsets);
importClass(java.security.Key);
importClass(java.lang.StringBuilder);

const CIPHER_ALGORITHM="AES/ECB/PKCS5Padding";
const DEFAULT_VALUE="0";
const CHARSET_UTF8=StandardCharsets.UTF_8;
const SECRET_KEY_LENGTH=32;
const KEY_ALGORITHM = "AES";

var dt=encrypt('test',"11111ew23211111111111")
//var dt=stringToByte("test");
console.log('加密内容：'+dt)
//var re=Uint8ArrayToString(dt)
var re=decrypt(dt,"11111ew23211111111111")
console.log('解密内容：'+re)
 /**
 * 加密密码，长度：16 或 32 个字符(随便定义)
 */
function encrypt(data,secretKey) {
    try {
        //创建密码器
        var cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        //初始化为加密密码器
        cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(secretKey));
        var encryptByte = cipher.doFinal(stringToByte(data));
        // 将加密以后的数据进行 Base64 编码
        return base64Encode(encryptByte);
    } catch (e) {
        console.log(e);
    }
    return null;
}

 /**
 * AES 解密
 *
 *加密的密文 Base64 字符串
 */
function decrypt(base64Data,secretKey) {
    try {
        var data = base64Decode(base64Data);
        var cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        //设置为解密模式
        cipher.init(Cipher.DECRYPT_MODE, getSecretKey(secretKey));
        //执行解密操作
        var result = cipher.doFinal(data);
        var str=Uint8ArrayToString(result)
        return str;
    } catch (e) {
        console.log(e);
    }
    return null;
}

    /**
     * 将 Base64 字符串 解码成 字节数组
     */
     function base64Decode(data) {
        return Base64.decode(data, Base64.NO_WRAP);
    }
     /**
     * 将 字节数组 转换成 Base64 编码
     */
      function base64Encode(data) {
        return Base64.encodeToString(data, Base64.NO_WRAP);
    }

    function getSecretKey(secretKey) {
        secretKey = toMakeKey(secretKey, SECRET_KEY_LENGTH, DEFAULT_VALUE);

        var dto=new SecretKeySpec(stringToByte(secretKey), KEY_ALGORITHM)
        return  dto;
    }

    function toMakeKey(secretKey,length,text) {
        // 获取密钥长度
        var strLen = secretKey.length;
        
        // 判断长度是否小于应有的长度
        if (strLen < length) {
            // 补全位数
            var builder = new StringBuilder();
            // 将key添加至builder中
            builder.append(secretKey);
            // 遍历添加默认文本
            for (var i = 0; i < length - strLen; i++) {
                builder.append(text);
            }
            // 赋值
            secretKey = builder.toString();
        }
        return secretKey;
    }

    // 字符串转数组
    function stringToByte(str) {
        var len, c;
        len = str.length;
        var bytes = [];
        for(var i = 0; i < len; i++) {
            c = str.charCodeAt(i);
            if(c >= 0x010000 && c <= 0x10FFFF) {
                bytes.push(((c >> 18) & 0x07) | 0xF0);
                bytes.push(((c >> 12) & 0x3F) | 0x80);
                bytes.push(((c >> 6) & 0x3F) | 0x80);
                bytes.push((c & 0x3F) | 0x80);
            } else if(c >= 0x000800 && c <= 0x00FFFF) {
                bytes.push(((c >> 12) & 0x0F) | 0xE0);
                bytes.push(((c >> 6) & 0x3F) | 0x80);
                bytes.push((c & 0x3F) | 0x80);
            } else if(c >= 0x000080 && c <= 0x0007FF) {
                bytes.push(((c >> 6) & 0x1F) | 0xC0);
                bytes.push((c & 0x3F) | 0x80);
            } else {
                bytes.push(c & 0xFF);
            }
        }
        return bytes;
    }

    function Uint8ArrayToString(fileData){
        var dataString = "";
        for (var i = 0; i < fileData.length; i++) {
          dataString += String.fromCharCode(fileData[i]);
        }
       
        return dataString
      
      }

这是Java的AEC加解密

package com.example.potatocrd.ui.main.up;


import android.os.Build;
import android.util.Base64;
import androidx.annotation.RequiresApi;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.Buffer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.security.Key;

/**
 * AEC加解密工具类
 * @author Lenovo
 */
@RequiresApi(api = Build.VERSION_CODES.KITKAT)
public class AecUtils {

    /**
     * 加密算法
     */
    private static final String KEY_ALGORITHM = "AES";

    /**
     * AES 的 密钥长度，32 字节，范围：16 - 32 字节
     */
    public static final int SECRET_KEY_LENGTH = 32;

    /**
     * 字符编码
     */
    private static final Charset CHARSET_UTF8 = StandardCharsets.UTF_8;

    /**
     * 秘钥长度不足 16 个字节时，默认填充位数
     */
    private static final String DEFAULT_VALUE = "0";
    /**
     * 加解密算法/工作模式/填充方式
     */
    private static final String CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";
    /**
     * 加密密码，长度：16 或 32 个字符(随便定义)
     */
    public static String encrypt(String data, String secretKey) {
        try {
            //创建密码器
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            //初始化为加密密码器
            cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(secretKey));
            byte[] encryptByte = cipher.doFinal(data.getBytes(CHARSET_UTF8));
            // 将加密以后的数据进行 Base64 编码
            return base64Encode(encryptByte);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * AES 解密
     *
     * @param base64Data 加密的密文 Base64 字符串
     */
    public static String decrypt(String base64Data, String secretKey) {
        try {
            byte[] data = base64Decode(base64Data);
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            //设置为解密模式
            cipher.init(Cipher.DECRYPT_MODE, getSecretKey(secretKey));
            //执行解密操作
            byte[] result = cipher.doFinal(data);
            return new String(result, CHARSET_UTF8);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 将 Base64 字符串 解码成 字节数组
     */
    public static byte[] base64Decode(String data) {
        return Base64.decode(data, Base64.NO_WRAP);
    }

    /**
     * 将 字节数组 转换成 Base64 编码
     */
    public static String base64Encode(byte[] data) {
        return Base64.encodeToString(data, Base64.NO_WRAP);
    }

    /**
     * 使用密码获取 AES 秘钥
     * @return
     */
    public static Key getSecretKey(String secretKey) {
        secretKey = toMakeKey(secretKey, SECRET_KEY_LENGTH, DEFAULT_VALUE);
        return new SecretKeySpec(secretKey.getBytes(CHARSET_UTF8), KEY_ALGORITHM);
    }
    private static String toMakeKey(String secretKey, int length, String text) {
        // 获取密钥长度
        int strLen = secretKey.length();
        // 判断长度是否小于应有的长度
        if (strLen < length) {
            // 补全位数
            StringBuilder builder = new StringBuilder();
            // 将key添加至builder中
            builder.append(secretKey);
            // 遍历添加默认文本
            for (int i = 0; i < length - strLen; i++) {
                builder.append(text);
            }
            // 赋值
            secretKey = builder.toString();
        }
        return secretKey;
    }

    public static void main(String[] args) {
        String aaa="aaa";
        final byte b = StringBuilder.
        final byte[] bytes = aaa.getBytes();

    }
}