1. 项目概述：为什么要在Java里实现SMS4？

如果你是一名Java开发者，尤其是在处理金融、物联网设备通信或者需要遵循特定国密标准的项目中，你很可能听说过或者被要求实现SMS4算法。SMS4，这个听起来有点陌生的名字，其实是国内商用密码体系中的一个核心对称加密算法，主要用于无线局域网产品的加密。虽然它的名字不如AES、DES那么如雷贯耳，但在特定的合规性场景下，它就是那个“必须项”。

我最初接触SMS4，是在一个与硬件设备进行安全通信的物联网项目中。设备端固件已经按照国密标准实现了SMS4，而我们的Java后端服务需要与之对接，进行数据的加密和解密。当时市面上成熟的、经过充分验证的Java实现库并不多，直接使用一些开源代码又担心存在隐蔽的漏洞或性能瓶颈。于是，我决定自己动手，从算法原理开始，实现一个清晰、高效且易于集成的Java版本。这个过程不仅让我吃透了SMS4的每一个步骤，也积累了大量关于在Java中实现底层加密算法的实战经验。

这个项目的目的，就是带你走一遍我走过的路。不仅仅是给你一段可以“复制粘贴”的源码，更重要的是，我会拆解SMS4的每一轮运算，解释每一个S盒、循环移位的设计意图，并分享在Java中实现时需要注意的性能陷阱和内存细节。无论你是为了应对面试中关于国密算法的问题，还是真正有项目需要，这篇文章都能给你提供一个从理论到实践的完整参考。最终，你会得到一个结构清晰、注释完备、可以直接用于非关键教学或测试环境的SMS4工具类。

2. SMS4算法核心原理深度拆解

在动手写代码之前，我们必须先搞清楚SMS4到底是怎么工作的。它是一种分组密码算法，分组长度和密钥长度均为128位。算法整体结构采用32轮非线性迭代结构（Feistel结构的一种变体），这一点和DES类似，但具体操作函数完全不同。

2.1 算法基本流程与核心部件

SMS4的加密过程可以概括为以下几个步骤：

1. 输入处理 ：将128位的明文分成4个32位的字（X0, X1, X2, X3）。
2. 32轮迭代 ：进行32轮相同的轮函数F运算。每一轮都会生成一个新的32位字，并更新状态。
3. 反序变换 ：32轮迭代结束后，对最后得到的4个字进行反序输出，得到128位的密文。

它的核心秘密藏在 轮函数F 和 T变换 里。

轮函数 F(Xi, Xi+1, Xi+2, Xi+3, rki) 的定义是： F = Xi ⊕ T(Xi+1 ⊕ Xi+2 ⊕ Xi+3 ⊕ rki) 其中， Xi 到 Xi+3 是当前轮输入的四个字， rki 是当前轮的轮密钥， ⊕ 代表32位的异或运算。 T 变换是整个算法的强度所在。

T 变换又由两个部分复合而成： T(.) = L(τ(.)) 。

• τ变换 ：这是一个非线性字节替代变换。它将一个32位的输入字（A）拆分成4个字节（a0, a1, a2, a3），然后对每个字节独立地进行S盒替换。SMS4的S盒是一个固定的8位输入、8位输出的查找表，是经过精心设计具有高非线性度的部件。τ变换的输出是另一个32位的字（B）。
• L变换 ：这是一个线性扩散变换。它对τ变换输出的32位字B进行运算，定义为： L(B) = B ⊕ (B <<< 2) ⊕ (B <<< 10) ⊕ (B <<< 18) ⊕ (B <<< 24) 。这里的 <<< 表示32位循环左移。这个操作的目的在于让单个字节的变化能快速扩散到整个字乃至整个分组，提供良好的雪崩效应。

注意 ：SMS4的S盒是固定的，与密钥无关。这与AES等算法不同。在实现时，我们必须严格使用标准文档中定义的S盒数据，任何细微的偏差都会导致加解密失败。

2.2 密钥扩展算法解析

一个安全的加密算法，密钥扩展过程同样关键。SMS4的加密密钥MK也是128位，同样分为4个32位的字（MK0, MK1, MK2, MK3）。

密钥扩展的大致步骤如下：

1. 首先，用一个固定的系统参数FK（4个32位字）与MK进行异或，得到中间值(K0, K1, K2, K3)。
2. 然后，通过一个与轮函数F类似的变换（但使用固定的加密密钥扩展参数CK），迭代32轮，生成32个轮密钥rki。

具体公式为： rki = Ki+4 = Ki ⊕ T'(Ki+1 ⊕ Ki+2 ⊕ Ki+3 ⊕ CKi) 这里的 T' 变换与加密中的 T 变换非常相似，唯一的区别在于线性变换 L' 被替换为： L'(B) = B ⊕ (B <<< 13) ⊕ (B <<< 23) 。这个设计使得加密的轮密钥和密钥扩展过程本身的结构类似但参数不同，增加了算法的整体复杂性。

为什么需要独立的密钥扩展？ 直接使用主密钥进行多轮加密是极不安全的。密钥扩展算法就像一个“密钥搅拌机”，将短的、易记的用户密钥（主密钥）扩展成一系列与每一轮加密紧密相关的、看起来随机的轮密钥。即使攻击者破解了某一轮的轮密钥，也很难逆推出主密钥。SMS4的密钥扩展算法同样包含了非线性S盒和线性扩散，确保了轮密钥之间的复杂性和独立性。

理解这些原理，是我们写出正确、高效代码的基础。接下来，我们就进入实战环节。

3. Java实现SMS4的关键步骤与编码

我们将按照模块化的思想来实现SMS4，主要分为以下几个部分：常量定义（S盒、FK、CK）、基础工具方法（字节与整型转换、循环左移）、T变换与T‘变换、轮函数F、密钥扩展以及最终的加解密流程控制。

3.1 常量定义与基础工具类

首先，我们需要将算法标准中定义的所有常量“搬”到Java代码里。我会将它们放在一个名为 SMS4Constants 的类中，使用 static final 数组来定义。

public class SMS4Constants {
    // S盒，256个字节，此处为示例，需填充完整数据
    public static final byte[] S_BOX = {
        (byte)0xd6, (byte)0x90, (byte)0xe9, (byte)0xfe, (byte)0xcc, (byte)0xe1, ... // 完整256个值
    };

    // 系统参数 FK
    public static final int[] FK = {0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc};

    // 固定参数 CK，共32个，此处为示例
    public static final int[] CK = {
        0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
        0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
        ... // 完整32个值
    };
}

实操心得 ：在定义S盒和CK这种大型常量数组时，务必通过单元测试或与官方文档逐字节比对来确保数据绝对正确。一个字节的错误就会导致整个加解密过程失败，且这种错误非常隐蔽，难以调试。我建议将标准文档中的十六进制数据复制到文本编辑器，然后用一个小脚本或手动仔细地转换成Java的byte或int数组。

接着，我们创建一个 SMS4Util 工具类，包含一些基础操作。

public class SMS4Util {
    /**
     * 32位循环左移
     * @param x 待移位的整数
     * @param n 左移的位数
     * @return 循环左移后的结果
     */
    public static int rotateLeft(int x, int n) {
        return (x << n) | (x >>> (32 - n)); // 使用无符号右移
    }

    /**
     * 将4个字节转换为一个int (大端序)
     */
    public static int bytesToInt(byte[] b, int offset) {
        return ((b[offset] & 0xFF) << 24) |
               ((b[offset + 1] & 0xFF) << 16) |
               ((b[offset + 2] & 0xFF) << 8) |
               (b[offset + 3] & 0xFF);
    }

    /**
     * 将一个int转换为4个字节 (大端序)
     */
    public static void intToBytes(int n, byte[] b, int offset) {
        b[offset] = (byte) (n >> 24);
        b[offset + 1] = (byte) (n >> 16);
        b[offset + 2] = (byte) (n >> 8);
        b[offset + 3] = (byte) n;
    }
}

这里的关键点是 rotateLeft 方法。Java的 int 是32位有符号整数，直接使用 << 和 >> 进行移位时，符号位会参与并可能引起问题。我们使用 >>> （无符号右移）来确保高位补0，从而实现正确的循环左移。 bytesToInt 和 intToBytes 方法则确保了字节数组与整型数之间按照大端序（网络字节序）进行转换，这是密码算法中的常见约定。

3.2 实现T变换与轮函数

有了基础工具，我们就可以实现核心的 T 变换和轮函数 F 了。我们先实现用于加密的 T 变换。

public class SMS4Cipher {
    private static final int[] S_BOX_INT = new int[256]; // 将S盒转换为int数组避免频繁转型

    static {
        // 初始化S盒的int版本，性能优化
        for (int i = 0; i < 256; i++) {
            S_BOX_INT[i] = SMS4Constants.S_BOX[i] & 0xFF;
        }
    }

    /**
     * τ变换：非线性字节替换
     */
    private static int tau(int input) {
        int b0 = S_BOX_INT[(input >> 24) & 0xFF];
        int b1 = S_BOX_INT[(input >> 16) & 0xFF];
        int b2 = S_BOX_INT[(input >> 8) & 0xFF];
        int b3 = S_BOX_INT[input & 0xFF];
        return (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
    }

    /**
     * L变换：线性扩散
     */
    private static int lTransform(int b) {
        return b ^ SMS4Util.rotateLeft(b, 2) ^
                     SMS4Util.rotateLeft(b, 10) ^
                     SMS4Util.rotateLeft(b, 18) ^
                     SMS4Util.rotateLeft(b, 24);
    }

    /**
     * T变换：T(.) = L(τ(.))
     */
    private static int tTransform(int input) {
        return lTransform(tau(input));
    }

    /**
     * 轮函数 F
     * @param x0 输入字0
     * @param x1 输入字1
     * @param x2 输入字2
     * @param x3 输入字3
     * @param rk 轮密钥
     * @return 本轮输出字
     */
    private static int roundFunction(int x0, int x1, int x2, int x3, int rk) {
        return x0 ^ tTransform(x1 ^ x2 ^ x3 ^ rk);
    }
}

为什么将S盒转换为int数组？ 这是一个重要的性能优化点。在 tau 变换中，我们需要对S盒进行大量查找。如果直接使用 byte[] S_BOX ，每次查找 S_BOX[index] 得到的是一个 byte ，在与 int 进行位运算时会发生符号扩展（ byte 被提升为 int ），如果 byte 是负数（最高位为1），扩展后高位会补1，导致结果错误。通常的写法是 S_BOX[index] & 0xFF 来将其转换为无符号的int。在静态初始化块中预先计算好这个转换结果，存到 S_BOX_INT 里，在 tau 方法中就可以直接使用，避免了每次查找都进行 & 0xFF 的操作，在32轮加密中，这个优化能带来可观的性能提升。

3.3 密钥扩展算法的实现

密钥扩展是独立的模块，它生成加密和解密所需的轮密钥。注意，解密轮密钥是加密轮密钥的逆序。

public class SMS4Cipher {
    // ... 接上文代码

    /**
     * T‘变换，用于密钥扩展，与T变换的区别在于L’变换
     */
    private static int tTransformPrime(int input) {
        return lTransformPrime(tau(input));
    }

    private static int lTransformPrime(int b) {
        return b ^ SMS4Util.rotateLeft(b, 13) ^ SMS4Util.rotateLeft(b, 23);
    }

    /**
     * 生成轮密钥
     * @param mk 主密钥，16字节
     * @param forEncryption true生成加密轮密钥，false生成解密轮密钥（逆序）
     * @return 32个轮密钥的数组
     */
    public static int[] generateRoundKeys(byte[] mk, boolean forEncryption) {
        if (mk.length != 16) {
            throw new IllegalArgumentException("主密钥长度必须为16字节(128位)");
        }

        int[] k = new int[36]; // K0-K35
        int[] rk = new int[32]; // rk0-rk31

        // 1. (K0, K1, K2, K3) = (MK0, MK1, MK2, MK3) ⊕ (FK0, FK1, FK2, FK3)
        for (int i = 0; i < 4; i++) {
            k[i] = SMS4Util.bytesToInt(mk, i * 4) ^ SMS4Constants.FK[i];
        }

        // 2. 迭代生成 K4 - K35，同时得到轮密钥 rki = K_{i+4}
        for (int i = 0; i < 32; i++) {
            int tmp = k[i + 1] ^ k[i + 2] ^ k[i + 3] ^ SMS4Constants.CK[i];
            k[i + 4] = k[i] ^ tTransformPrime(tmp);
            rk[i] = k[i + 4];
        }

        // 3. 如果是解密，需要将轮密钥逆序
        if (!forEncryption) {
            reverseArray(rk);
        }
        return rk;
    }

    private static void reverseArray(int[] arr) {
        for (int i = 0; i < 16; i++) {
            int temp = arr[i];
            arr[i] = arr[31 - i];
            arr[31 - i] = temp;
        }
    }
}

密钥扩展的逻辑严格遵循了标准。首先生成加密轮密钥，如果需要解密密钥，只需简单地将这个数组逆序即可。这是因为SMS4的加密和解密算法结构完全相同，唯一的区别就是轮密钥的使用顺序相反。 generateRoundKeys 方法返回一个包含32个 int 的数组，在加解密时直接按索引使用。

3.4 完整的加解密流程整合

最后，我们将所有模块组合起来，实现 encrypt 和 decrypt 方法。

public class SMS4Cipher {
    // ... 接上文所有代码

    /**
     * SMS4 ECB模式加密（仅用于演示，实际生产环境应使用更安全的模式如CBC）
     * @param input 明文，长度必须是16字节的倍数
     * @param key 16字节密钥
     * @return 密文
     */
    public static byte[] encrypt(byte[] input, byte[] key) {
        checkInput(input, key);
        int[] roundKeys = generateRoundKeys(key, true);

        byte[] output = new byte[input.length];
        // 按16字节分组处理
        for (int i = 0; i < input.length; i += 16) {
            encryptBlock(input, i, output, i, roundKeys);
        }
        return output;
    }

    /**
     * SMS4 ECB模式解密
     */
    public static byte[] decrypt(byte[] input, byte[] key) {
        checkInput(input, key);
        int[] roundKeys = generateRoundKeys(key, false); // 使用解密轮密钥

        byte[] output = new byte[input.length];
        for (int i = 0; i < input.length; i += 16) {
            encryptBlock(input, i, output, i, roundKeys); // 解密过程与加密相同，只是轮密钥顺序相反
        }
        return output;
    }

    private static void checkInput(byte[] data, byte[] key) {
        if (key.length != 16) {
            throw new IllegalArgumentException("密钥长度必须为16字节");
        }
        if (data.length % 16 != 0) {
            throw new IllegalArgumentException("数据长度必须是16字节的倍数");
        }
    }

    /**
     * 加密/解密单个16字节分组
     * @param input 输入数组
     * @param inOff 输入起始偏移
     * @param output 输出数组
     * @param outOff 输出起始偏移
     * @param roundKeys 轮密钥（加密或解密的）
     */
    private static void encryptBlock(byte[] input, int inOff, byte[] output, int outOff, int[] roundKeys) {
        // 1. 输入反序变换（解密时对应最后的反序输出）
        int x0 = SMS4Util.bytesToInt(input, inOff);
        int x1 = SMS4Util.bytesToInt(input, inOff + 4);
        int x2 = SMS4Util.bytesToInt(input, inOff + 8);
        int x3 = SMS4Util.bytesToInt(input, inOff + 12);

        // 2. 32轮迭代
        for (int i = 0; i < 32; i++) {
            int x4 = roundFunction(x0, x1, x2, x3, roundKeys[i]);
            // 状态更新
            x0 = x1;
            x1 = x2;
            x2 = x3;
            x3 = x4;
        }

        // 3. 反序变换并输出 (R)
        SMS4Util.intToBytes(x3, output, outOff);
        SMS4Util.intToBytes(x2, output, outOff + 4);
        SMS4Util.intToBytes(x1, output, outOff + 8);
        SMS4Util.intToBytes(x0, output, outOff + 12);
    }
}

这里有几个关键点需要解释：

1. 分组处理 ：SMS4是分组密码，一次处理16字节。我们的 encrypt 和 decrypt 方法处理任意长度的数据，但要求长度是16的倍数。这通常需要配合 分组密码工作模式 （如CBC、CTR）和 填充方案 （如PKCS#7）来使用，本文为聚焦算法核心，仅实现了最简单的ECB模式。
2. 加解密的统一 ：注意 decrypt 方法内部调用了 encryptBlock 。这是因为SMS4算法的加解密过程完全对称，只是轮密钥顺序相反。我们在 generateRoundKeys 时已经处理了顺序问题，所以加解密可以共用同一套迭代逻辑。
3. 反序变换 ：在加密时，明文输入后先进行反序（ (X0, X1, X2, X3) 作为初始状态），迭代结束后再反序输出。在我们的 encryptBlock 中，第一步的字节转int就是输入反序（因为我们按顺序读入X0-X3），最后一步的int转字节并倒序写入就是输出反序。

至此，一个完整的、可运行的SMS4算法Java实现就完成了。你可以编写一个简单的 main 方法进行测试。

4. 性能优化、安全考量与生产环境建议

实现一个能跑通的算法只是第一步。要让它在实际项目中可用，我们还需要考虑性能、安全性以及如何正确地集成。

4.1 性能优化实战技巧

密码运算是计算密集型操作。在Java中实现，我们可以从以下几个层面进行优化：

1. 查表法优化T变换 ：这是最有效的优化手段。 T 变换包含一个S盒查表和四次循环左移异或。我们可以预先计算一个大小为256的 int 数组 TABLE_T ，使得 TABLE_T[b] = L(S_BOX[b]) ，这里 b 是一个字节（0-255）。那么，对于一个32位输入 A ， T(A) 可以拆分为4个字节并行查表然后合并： T(A) = TABLE_T[(A>>24)&0xFF] ^ rotateLeft(TABLE_T[(A>>16)&0xFF], 8) ^ rotateLeft(TABLE_T[(A>>8)&0xFF], 16) ^ rotateLeft(TABLE_T[A&0xFF], 24) 。这能将一轮中多次的S盒查找和复杂的L变换，简化为4次查表和3次移位异或，性能提升显著。

2. 循环展开 ：在 encryptBlock 的32轮循环中，可以尝试进行部分循环展开（例如每次迭代处理2轮），减少循环计数器的开销。但现代JVM的JIT编译器已经非常智能，会自动进行一些优化，手动展开的收益需要实测。

3. 避免不必要的对象创建 ：在 encrypt / decrypt 方法中，我们为结果创建了新的 byte[] 。在频繁调用的场景下，可以考虑让调用者传入输出缓冲区，避免大量临时对象分配带来的GC压力。

4. 使用 int 而非 byte 进行内部运算 ：我们全程使用 int 来存储32位字，这符合CPU的字长，效率远高于用 byte 数组直接操作。

一个优化后的 T 变换示例：

private static final int[] TABLE_T = new int[256];
static {
    // 初始化优化表
    for (int i = 0; i < 256; i++) {
        int b = S_BOX_INT[i]; // 经过S盒
        // 应用L变换: L(B) = B ^ (B<<<2) ^ (B<<<10) ^ (B<<<18) ^ (B<<<24)
        int lb = b ^ SMS4Util.rotateLeft(b, 2) ^ SMS4Util.rotateLeft(b, 10) ^ SMS4Util.rotateLeft(b, 18) ^ SMS4Util.rotateLeft(b, 24);
        TABLE_T[i] = lb;
    }
}

private static int tTransformFast(int a) {
    return TABLE_T[(a >> 24) & 0xFF] ^
           SMS4Util.rotateLeft(TABLE_T[(a >> 16) & 0xFF], 8) ^
           SMS4Util.rotateLeft(TABLE_T[(a >> 8) & 0xFF], 16) ^
           SMS4Util.rotateLeft(TABLE_T[a & 0xFF], 24);
}

4.2 安全使用指南与常见陷阱

自己实现密码算法用于生产环境需要极度谨慎。以下是一些重要的安全提醒：

1. 不要用于真正的安全通信 ：本文的实现是用于学习和理解算法原理。对于实际生产系统， 强烈建议使用经过广泛审计、成熟稳定的密码库 ，如Bouncy Castle（BC）Provider。BC库中已经提供了经过充分测试和优化的SMS4实现。自己实现的代码很难保证没有侧信道攻击（如时间攻击）漏洞，也缺乏对抗故障攻击等高级攻击的防护。

2. 工作模式与填充 ：我们只实现了ECB模式。ECB模式是极不安全的，因为相同的明文块会产生相同的密文块，会暴露数据模式。在实际中， 必须使用CBC、CTR、GCM等更安全的工作模式 。同时，需要处理数据长度不是分组整数倍的情况，这就需要使用PKCS#7等填充标准。

3. 密钥管理 ：密钥的安全存储、分发和生命周期管理比算法实现本身更重要。永远不要将硬编码的密钥放在客户端代码或配置文件中。

4. 初始化向量（IV） ：对于CBC等模式，需要一个随机且不可预测的IV，并且每次加密都应使用新的IV。IV不需要保密，但必须随密文一起传输。

4.3 集成到现有项目与测试

如果你需要在测试或特定合规环境（如与特定硬件交互，且双方均使用此实现）中使用本代码，以下是一些集成建议：

1. 封装成Service ：创建一个 SMS4Service ，内部使用优化后的 SMS4Cipher ，并提供更友好的API，例如支持字符串的Base64编码输入输出，自动处理工作模式（如CBC）和填充。

2. 编写完备的单元测试 ：使用国密标准文档或权威测试向量（如GM/T 0002-2012标准附录中的示例）来验证你的实现。确保加密后再解密能得到原始数据。测试应覆盖边界情况，如全0数据、全1数据等。

3. 性能基准测试 ：使用JMH（Java Microbenchmark Harness）对加解密方法进行基准测试，对比优化前后的性能，并与Bouncy Castle的实现进行对比，做到心中有数。

4. 错误处理 ：完善代码中的异常处理，对密钥长度错误、数据长度错误、空指针等提供清晰的异常信息。

5. 问题排查与实战调试记录

在实现和集成过程中，你肯定会遇到各种问题。下面是我踩过的一些坑以及解决方法，希望能帮你快速定位。

5.1 加解密结果不对

这是最常见的问题。请按照以下清单逐步排查：

问题现象	可能原因	排查方法
解密后得到乱码，与明文不符	1. S盒数据错误。 2. 字节序（大端/小端）弄错。 3. 轮密钥生成错误（FK、CK或T‘变换）。 4. 加解密轮密钥顺序弄反。	1. 逐字节核对S盒、FK、CK 与标准文档。这是最可能的原因。 2. 验证 bytesToInt 和 intToBytes 。用已知值测试，如 0x12345678 转字节再转回int看是否一致。 3. 单步调试密钥扩展 。计算第一轮轮密钥 rk0 ，与标准测试向量对比。 4. 确认加密时 generateRoundKeys 第二个参数为 true ，解密时为 false 。
只有前16字节正确，后面全错	工作在ECB模式，但分组处理逻辑有误，导致分组偏移计算错误。	检查 encrypt 方法中的循环， i 的步进必须是16。检查 encryptBlock 中 inOff 和 outOff 的计算是否正确传递。
解密时抛出数组越界等异常	密文长度不是16字节的倍数，或者填充处理逻辑有误。	确保传入解密函数的数据长度是16的倍数。如果使用了填充，先验证填充移除逻辑。

一个黄金调试法则：使用官方测试向量。 找到GM/T 0002-2012标准文档，里面会有完整的加密示例：给定密钥、明文，计算出密文。用你的程序加密同样的密钥和明文，逐轮、逐字比对中间结果（如每一轮迭代后的 X0, X1, X2, X3 和 rki ），直到找到第一个出现差异的地方，那里就是bug所在。

5.2 性能达不到预期

如果你发现自己的实现比预期慢很多：

1. 检查是否使用了优化后的 T 变换 （查表法）。这是最大的性能瓶颈。
2. 使用JProfiler或VisualVM等工具进行性能分析 ，查看热点在哪里。很可能时间都花在了 tau 变换中的S盒查找和位运算上。
3. 确保JVM运行在Server模式 （ -server 参数），并给予足够的热身时间（Warm-up），让JIT编译器优化生效。
4. 对比Bouncy Castle 。如果性能仍相差甚远，可以反编译或查看BC的源码，学习其更底层的优化技巧，例如使用 Unsafe 类进行直接内存操作等（但这会牺牲可读性和安全性）。

5.3 与其它系统（如C语言硬件）对接失败

当你的Java程序需要与用C语言实现的硬件设备进行SMS4通信时，即使算法正确，也可能因为以下原因失败：

1. 字节序问题 ：虽然我们约定使用大端序，但有些嵌入式系统或旧的代码库可能使用小端序。双方必须严格统一。在数据交换前，明确文档约定。
2. 工作模式和填充 ：硬件端使用的是什么模式？CBC？IV是如何传递和约定的？使用什么填充？PKCS#5还是PKCS#7？这些必须完全一致。
3. 密钥和IV的编码 ：密钥和IV是以十六进制字符串形式传递，还是直接传递二进制字节流？需要确认编码方式。

对接建议 ：首先在双方都使用 相同、已知的测试向量 进行自测，确保各自实现正确。然后，设计一个最简单的端到端测试：硬件加密一段固定数据，Java端解密；Java加密一段数据，硬件解密。从最简单的ECB模式、无填充开始测试，逐步增加复杂度到实际使用的CBC模式和填充。

实现一个密码算法是一次深刻的学习之旅，它迫使你关注每一个比特的流动。通过这个SMS4的Java实现项目，你不仅获得了一个可用的工具，更重要的是理解了分组密码设计的基本思想——混淆与扩散，以及如何在软件中平衡安全、性能和正确性。记住，对于生产环境，信任经过时间考验的库（如Bouncy Castle）永远是更安全、更经济的选择。但自己动手实现一遍，这份经验会让你在后续使用这些库时，更能理解其背后的逻辑，在出现问题时也更有排查的思路。