package com.ruoyi.system.demo; import org.bitcoinj.crypto.ChildNumber; import org.bitcoinj.crypto.DeterministicKey; import org.bitcoinj.crypto.HDPath; import org.bitcoinj.crypto.MnemonicCode; import org.bitcoinj.wallet.DeterministicKeyChain; import org.bitcoinj.wallet.DeterministicSeed; import org.bouncycastle.jcajce.provider.digest.Keccak; import org.bouncycastle.math.ec.ECPoint; import javax.crypto.Cipher; import javax.crypto.SecretKeyFactory; import javax.crypto.spec.GCMParameterSpec; import javax.crypto.spec.PBEKeySpec; import javax.crypto.spec.SecretKeySpec; import java.math.BigInteger; import java.nio.charset.StandardCharsets; import java.security.MessageDigest; import java.security.SecureRandom; import java.util.ArrayList; import java.util.Arrays; import java.util.Base64; import java.util.List; /** * TRON 钱包信封加密演示。 *

* 助记词由随机 DEK 使用 AES-256-GCM 加密;DEK 再由配置密码派生的 KEK 加密。 * 配置密码验证哈希单独使用一组 salt。此类仅用于演示,不负责数据库持久化或业务授权。 */ public final class WalletEnvelopeEncryptionDemo { private static final int KEY_BYTES = 32; private static final int SALT_BYTES = 16; private static final int NONCE_BYTES = 12; /** Demo default; production should benchmark and normally use a much higher value. */ private static final int ITERATIONS = readIterations(); private static final SecureRandom RANDOM = new SecureRandom(); private static final BigInteger BASE58 = BigInteger.valueOf(58); private static final char[] BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".toCharArray(); private WalletEnvelopeEncryptionDemo() { } /** * 创建钱包主密钥。 * * 流程: * 1. 生成 128 位随机熵并转换为 12 个助记词。 * 2. 生成随机 DEK(Data Encryption Key)。 * 3. DEK 使用 AES-256-GCM 加密助记词,得到 encryptedMnemonic。 * 4. 配置密码通过 PBKDF2 派生 KEK(Key Encryption Key)。 * 5. KEK 使用 AES-256-GCM 加密 DEK,得到 encryptedDek。 * 6. 同一助记词按 m/44'/195'/0'/0/i 派生主钱包和子钱包地址。 * * 数据库只应保存返回对象中的 envelope 字段和钱包地址/索引,不能保存 mnemonic。 */ public static DemoBundle create(char[] configurationPassword, int childCount) throws Exception { requirePassword(configurationPassword); if (childCount < 0 || childCount > 10000) throw new IllegalArgumentException("子钱包数量必须在 0 到 10000 之间"); byte[] entropy = random(16); List words = MnemonicCode.INSTANCE.toMnemonic(entropy); Arrays.fill(entropy, (byte) 0); String mnemonic = join(words); EncryptedEnvelope envelope = encrypt(mnemonic, configurationPassword); List wallets = deriveWallets(mnemonic, childCount + 1); return new DemoBundle(mnemonic, envelope, wallets); } /** * 解锁信封。 * * 先用 passwordSalt 验证密码,再用 keySalt 派生 KEK,解开 encryptedDek, * 最后用 DEK 解开 encryptedMnemonic。AES-GCM 会同时校验密文完整性。 * 返回的助记词只允许短时间存在于内存,调用方使用后必须清零 char[]。 */ public static char[] unlock(EncryptedEnvelope envelope, char[] configurationPassword) throws Exception { requirePassword(configurationPassword); verifyPassword(envelope, configurationPassword); byte[] kek = deriveKey(configurationPassword, decode(envelope.keySalt), envelope.iterations); byte[] dek = null; byte[] plaintext = null; try { dek = crypt(Cipher.DECRYPT_MODE, decode(envelope.encryptedDek), kek, decode(envelope.dekNonce)); plaintext = crypt(Cipher.DECRYPT_MODE, decode(envelope.encryptedMnemonic), dek, decode(envelope.mnemonicNonce)); return new String(plaintext, StandardCharsets.UTF_8).toCharArray(); } finally { Arrays.fill(kek, (byte) 0); if (dek != null) Arrays.fill(dek, (byte) 0); if (plaintext != null) Arrays.fill(plaintext, (byte) 0); } } /** * 轮换配置密码。 * * 这是“密码轮换”,不是“助记词轮换”: * 旧密码解开 DEK 后,用新密码派生的新 KEK 重新加密 DEK;助记词密文不变, * 因此主钱包、子钱包地址和历史订单映射保持不变。每次使用新的 salt 和 nonce, * 并将 version 加一。生产环境应在数据库事务中配合旧 version 做乐观锁更新。 */ public static EncryptedEnvelope rotateConfigurationPassword(EncryptedEnvelope oldEnvelope, char[] oldPassword, char[] newPassword) throws Exception { requirePassword(oldPassword); requirePassword(newPassword); verifyPassword(oldEnvelope, oldPassword); byte[] oldKek = deriveKey(oldPassword, decode(oldEnvelope.keySalt), oldEnvelope.iterations); byte[] dek = null; try { dek = crypt(Cipher.DECRYPT_MODE, decode(oldEnvelope.encryptedDek), oldKek, decode(oldEnvelope.dekNonce)); byte[] newSalt = random(SALT_BYTES); byte[] newNonce = random(NONCE_BYTES); byte[] newPasswordSalt = random(SALT_BYTES); byte[] newKek = deriveKey(newPassword, newSalt, ITERATIONS); byte[] wrappedDek; try { wrappedDek = crypt(Cipher.ENCRYPT_MODE, dek, newKek, newNonce); } finally { Arrays.fill(newKek, (byte) 0); } byte[] passwordHash = deriveKey(newPassword, newPasswordSalt, ITERATIONS); return new EncryptedEnvelope(oldEnvelope.version + 1, "AES-256-GCM", "PBKDF2-HMAC-SHA256", ITERATIONS, encode(oldEnvelope.encryptedMnemonicBytes()), encode(oldEnvelope.mnemonicNonceBytes()), encode(wrappedDek), encode(newNonce), encode(newSalt), encode(newPasswordSalt), encode(passwordHash)); } finally { Arrays.fill(oldKek, (byte) 0); if (dek != null) Arrays.fill(dek, (byte) 0); } } /** * 完整演示设置密码、旧密码解锁、密码轮换和新密码解锁。 * 返回的演示结果会包含新生成的助记词以便离线备份,但不包含密码、DEK 或 KEK;生产代码不要暴露该结果。 */ public static RotationDemoResult runPasswordRotationDemo(char[] oldPassword, char[] newPassword) throws Exception { requirePassword(oldPassword); requirePassword(newPassword); DemoBundle created = create(oldPassword, 5); List beforeRotation = created.wallets; char[] oldUnlockedMnemonic = unlock(created.envelope, oldPassword); List addressesBefore = deriveWallets(new String(oldUnlockedMnemonic), beforeRotation.size()); Arrays.fill(oldUnlockedMnemonic, '\0'); EncryptedEnvelope rotatedEnvelope = rotateConfigurationPassword(created.envelope, oldPassword, newPassword); boolean oldPasswordRejected; try { char[] shouldNotUnlock = unlock(rotatedEnvelope, oldPassword); Arrays.fill(shouldNotUnlock, '\0'); oldPasswordRejected = false; } catch (SecurityException expected) { oldPasswordRejected = true; } char[] newUnlockedMnemonic = unlock(rotatedEnvelope, newPassword); List addressesAfter = deriveWallets(new String(newUnlockedMnemonic), beforeRotation.size()); Arrays.fill(newUnlockedMnemonic, '\0'); boolean addressesUnchanged = sameAddresses(addressesBefore, addressesAfter) && sameAddresses(beforeRotation, addressesAfter); return new RotationDemoResult(created.envelope.version, rotatedEnvelope.version, oldPasswordRejected, true, addressesUnchanged, created.mnemonic, rotatedEnvelope, addressesAfter); } private static boolean sameAddresses(List left, List right) { if (left.size() != right.size()) return false; for (int i = 0; i < left.size(); i++) { if (left.get(i).index != right.get(i).index || !left.get(i).address.equals(right.get(i).address)) return false; } return true; } /** * 从同一助记词派生主钱包及子钱包,索引 0 为主钱包。 * token_index 必须与此处的 index 一致,路径固定为 m/44'/195'/0'/0/i。 * 这里只返回地址和派生路径,私钥不进入结果对象,避免误传到前端或日志。 */ public static List deriveWallets(String mnemonic, int walletCount) throws Exception { if (walletCount < 1 || walletCount > 10001) throw new IllegalArgumentException("钱包数量必须在 1 到 10001 之间"); List words = Arrays.asList(mnemonic.trim().toLowerCase().split("\\s+")); MnemonicCode.INSTANCE.check(words); DeterministicSeed seed = DeterministicSeed.ofMnemonic(words, ""); DeterministicKeyChain keyChain = DeterministicKeyChain.builder().seed(seed).build(); HDPath basePath = HDPath.M().extend(new ChildNumber(44, true), new ChildNumber(195, true), new ChildNumber(0, true), ChildNumber.ZERO); List wallets = new ArrayList(walletCount); for (int index = 0; index < walletCount; index++) { HDPath path = basePath.extend(new ChildNumber(index, false)); DeterministicKey key = keyChain.getKeyByPath(path, true); ECPoint publicPoint = key.getPubKeyPoint(); byte[] uncompressed = publicPoint.getEncoded(false); byte[] publicKey = Arrays.copyOfRange(uncompressed, 1, uncompressed.length); byte[] hash = new Keccak.Digest256().digest(publicKey); byte[] address = new byte[21]; address[0] = 0x41; System.arraycopy(hash, 12, address, 1, 20); wallets.add(new DerivedWallet(index, "m/44'/195'/0'/0/" + index, base58Check(address))); Arrays.fill(uncompressed, (byte) 0); Arrays.fill(publicKey, (byte) 0); Arrays.fill(hash, (byte) 0); Arrays.fill(address, (byte) 0); } return wallets; } /** 执行信封加密;password 只在本方法调用期间使用,不写入任何持久化对象。 */ private static EncryptedEnvelope encrypt(String mnemonic, char[] password) throws Exception { byte[] dek = random(KEY_BYTES), keySalt = random(SALT_BYTES), dekNonce = random(NONCE_BYTES); byte[] mnemonicNonce = random(NONCE_BYTES), passwordSalt = random(SALT_BYTES); byte[] kek = deriveKey(password, keySalt, ITERATIONS); try { byte[] encryptedMnemonic = crypt(Cipher.ENCRYPT_MODE, mnemonic.getBytes(StandardCharsets.UTF_8), dek, mnemonicNonce); byte[] encryptedDek = crypt(Cipher.ENCRYPT_MODE, dek, kek, dekNonce); byte[] passwordHash = deriveKey(password, passwordSalt, ITERATIONS); return new EncryptedEnvelope(1, "AES-256-GCM", "PBKDF2-HMAC-SHA256", ITERATIONS, encode(encryptedMnemonic), encode(mnemonicNonce), encode(encryptedDek), encode(dekNonce), encode(keySalt), encode(passwordSalt), encode(passwordHash)); } finally { Arrays.fill(dek, (byte) 0); Arrays.fill(kek, (byte) 0); } } private static void verifyPassword(EncryptedEnvelope envelope, char[] password) throws Exception { byte[] candidate = deriveKey(password, decode(envelope.passwordSalt), envelope.iterations); byte[] expected = decode(envelope.passwordHash); try { if (!MessageDigest.isEqual(candidate, expected)) throw new SecurityException("配置密码错误"); } finally { Arrays.fill(candidate, (byte) 0); Arrays.fill(expected, (byte) 0); } } /** PBKDF2 派生 256 位 KEK 或密码验证值;salt 和 iterations 必须随密文保存。 */ private static byte[] deriveKey(char[] password, byte[] salt, int iterations) throws Exception { PBEKeySpec spec = new PBEKeySpec(password, salt, iterations, KEY_BYTES * 8); try { return SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256").generateSecret(spec).getEncoded(); } finally { spec.clearPassword(); } } private static byte[] crypt(int mode, byte[] input, byte[] key, byte[] nonce) throws Exception { Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); cipher.init(mode, new SecretKeySpec(key, "AES"), new GCMParameterSpec(128, nonce)); return cipher.doFinal(input); } private static String base58Check(byte[] payload) throws Exception { byte[] first = MessageDigest.getInstance("SHA-256").digest(payload); byte[] second = MessageDigest.getInstance("SHA-256").digest(first); byte[] checked = Arrays.copyOf(payload, payload.length + 4); System.arraycopy(second, 0, checked, payload.length, 4); BigInteger value = new BigInteger(1, checked); StringBuilder out = new StringBuilder(); while (value.signum() > 0) { BigInteger[] div = value.divideAndRemainder(BASE58); out.append(BASE58_ALPHABET[div[1].intValue()]); value = div[0]; } for (byte b : checked) { if (b == 0) out.append(BASE58_ALPHABET[0]); else break; } Arrays.fill(first, (byte) 0); Arrays.fill(second, (byte) 0); Arrays.fill(checked, (byte) 0); return out.reverse().toString(); } private static byte[] random(int size) { byte[] bytes = new byte[size]; RANDOM.nextBytes(bytes); return bytes; } private static String encode(byte[] bytes) { return Base64.getEncoder().encodeToString(bytes); } private static byte[] decode(String text) { return Base64.getDecoder().decode(text); } private static String join(List words) { StringBuilder value = new StringBuilder(); for (String word : words) { if (value.length() > 0) value.append(' '); value.append(word); } return value.toString(); } private static void requirePassword(char[] password) { if (password == null || password.length < 10) throw new IllegalArgumentException("配置密码至少 10 位"); } private static int readIterations() { String configured = System.getProperty("wallet.demo.pbkdf2.iterations"); int value = 10000; if (configured != null) { try { value = Integer.parseInt(configured); } catch (NumberFormatException ignored) { } } if (value < 10000 || value > 1000000) throw new IllegalArgumentException("PBKDF2 迭代次数必须在 10000 到 1000000 之间"); return value; } /** * 交互式演示:输入旧密码和新密码,验证轮换前后地址不变。 * 仅在隔离的本机终端运行;生产服务绝不能打印 mnemonic、密码或私钥。 */ public static void main(String[] args) throws Exception { java.io.Console console = System.console(); if (console == null) throw new IllegalStateException("请在交互式本机终端运行"); char[] oldPassword = console.readPassword("Initial configuration password (10+ chars): "); char[] newPassword = console.readPassword("New configuration password (10+ chars): "); char[] confirmPassword = console.readPassword("Confirm new configuration password: "); if (newPassword == null || confirmPassword == null || !Arrays.equals(newPassword, confirmPassword)) { clear(oldPassword, newPassword, confirmPassword); throw new IllegalArgumentException("两次新密码不一致"); } Arrays.fill(confirmPassword, '\0'); try { RotationDemoResult result = runPasswordRotationDemo(oldPassword, newPassword); System.out.println("Mnemonic (write it down offline; never share or paste into support requests): " + result.mnemonic); System.out.println("Derived wallets (addresses only):"); for (DerivedWallet wallet : result.wallets) System.out.println(wallet.path + " " + wallet.address); System.out.println("Password rotation: version " + result.oldVersion + " -> " + result.newVersion); System.out.println("Old password rejected: " + result.oldPasswordRejected); System.out.println("New password unlock succeeded: " + result.newPasswordUnlockSucceeded); System.out.println("Derived addresses unchanged: " + result.addressesUnchanged); System.out.println("Mnemonic encryption: " + result.envelope.encryptionAlgorithm + ", KDF=" + result.envelope.passwordKdf + ", iterations=" + result.envelope.iterations); } finally { clear(oldPassword, newPassword); } } private static void clear(char[]... values) { if (values == null) return; for (char[] value : values) if (value != null) Arrays.fill(value, '\0'); } public static final class DemoBundle { public final String mnemonic; public final EncryptedEnvelope envelope; public final List wallets; private DemoBundle(String mnemonic, EncryptedEnvelope envelope, List wallets) { this.mnemonic = mnemonic; this.envelope = envelope; this.wallets = wallets; } } public static final class DerivedWallet { public final int index; public final String path; public final String address; private DerivedWallet(int index, String path, String address) { this.index = index; this.path = path; this.address = address; } @Override public String toString() { return path + " " + address; } } public static final class RotationDemoResult { public final int oldVersion; public final int newVersion; public final boolean oldPasswordRejected; public final boolean newPasswordUnlockSucceeded; public final boolean addressesUnchanged; /** * Sensitive: expose only in this local demo, never serialize or log in production. */ public final String mnemonic; public final EncryptedEnvelope envelope; public final List wallets; private RotationDemoResult(int oldVersion, int newVersion, boolean oldPasswordRejected, boolean newPasswordUnlockSucceeded, boolean addressesUnchanged, String mnemonic, EncryptedEnvelope envelope, List wallets) { this.oldVersion = oldVersion; this.newVersion = newVersion; this.oldPasswordRejected = oldPasswordRejected; this.newPasswordUnlockSucceeded = newPasswordUnlockSucceeded; this.addressesUnchanged = addressesUnchanged; this.mnemonic = mnemonic; this.envelope = envelope; this.wallets = wallets; } } /** * 可持久化的密文 DTO;不包含明文助记词、DEK 或 KEK。 */ public static final class EncryptedEnvelope { public final int version; public final String encryptionAlgorithm; public final String passwordKdf; public final int iterations; public final String encryptedMnemonic; public final String mnemonicNonce; public final String encryptedDek; public final String dekNonce; public final String keySalt; public final String passwordSalt; public final String passwordHash; /** * 用于从数据库反序列化已持久化的信封字段。 * 调用方只能传入密文、salt、nonce 等字段,绝不能把明文助记词放入此对象。 */ public EncryptedEnvelope(int version, String encryptionAlgorithm, String passwordKdf, int iterations, String encryptedMnemonic, String mnemonicNonce, String encryptedDek, String dekNonce, String keySalt, String passwordSalt, String passwordHash) { this.version = version; this.encryptionAlgorithm = encryptionAlgorithm; this.passwordKdf = passwordKdf; this.iterations = iterations; this.encryptedMnemonic = encryptedMnemonic; this.mnemonicNonce = mnemonicNonce; this.encryptedDek = encryptedDek; this.dekNonce = dekNonce; this.keySalt = keySalt; this.passwordSalt = passwordSalt; this.passwordHash = passwordHash; } private byte[] encryptedMnemonicBytes() { return decode(encryptedMnemonic); } private byte[] mnemonicNonceBytes() { return decode(mnemonicNonce); } } }