union-ark-web 1.0.1

package/ark-control/src/test/java/com/union/control/service/impl/SensitiveDataDemoServiceImplTest.java

@@ -0,0 +1,104 @@
+package com.union.control.service.impl;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.union.control.mapper.SensitiveAddressBookDemo;
+import com.union.control.mapper.SensitiveDataDemoMapper;
+import com.union.control.service.sensitive.SensitiveRevealService;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
+public class SensitiveDataDemoServiceImplTest {
+    private static final String TOKEN = "rt_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+    private static final String MASK = "[#138****8000#VIEW:" + TOKEN + "]";
+    private final ObjectMapper json = new ObjectMapper();
+    private final SensitiveDataDemoMapper mapper = mock(SensitiveDataDemoMapper.class);
+    private final SensitiveRevealService reveal = mock(SensitiveRevealService.class);
+    private final SensitiveDataDemoServiceImpl service = new SensitiveDataDemoServiceImpl(mapper, json, reveal);
+
+    @Test
+    public void saveResolvesUnopenedFragmentsPreservesNewlinesAndReturnsOnlyQueriedRow() throws Exception {
+        Map<String, Object> input = row("phoneNumber", " 新备注\n" + MASK + " ");
+        input.put("id", 7);
+        Map<String, Object> saved = row("phoneNumber", " 新备注\n" + MASK + " ");
+        saved.put("id", 7L);
+        when(reveal.reveal(anyString())).thenReturn("13800138000");
+        when(mapper.update(anyMap())).thenReturn(1);
+        when(mapper.queryById(7L)).thenReturn(saved);
+
+        assertSame(saved, service.save(json.writeValueAsString(input)));
+
+        ArgumentCaptor<Map> persisted = ArgumentCaptor.forClass(Map.class);
+        verify(mapper).update(persisted.capture());
+        assertEquals(" 新备注\n13800138000 ", persisted.getValue().get("phoneNumber"));
+        ArgumentCaptor<String> tokenInput = ArgumentCaptor.forClass(String.class);
+        verify(reveal).reveal(tokenInput.capture());
+        Map parsed = json.readValue(tokenInput.getValue(), Map.class);
+        assertEquals("user-1", parsed.get("userId"));
+        assertEquals(TOKEN, parsed.get("token"));
+    }
+
+    @Test
+    public void insertReturnsTheGeneratedIdRatherThanTheLatestRow() throws Exception {
+        doAnswer(call -> { ((Map) call.getArguments()[0]).put("id", 9L); return 1; })
+                .when(mapper).insertSaved(anyMap());
+        Map<String, Object> saved = row("phoneNumber", MASK);
+        when(mapper.queryById(9L)).thenReturn(saved);
+        Map<String, Object> input = row("phoneNumber", "13800138000");
+        input.put("id", null);
+        assertSame(saved, service.save(json.writeValueAsString(input)));
+        verify(mapper, never()).query();
+    }
+
+    @Test
+    public void addressBookEditResolvesOnlySensitiveValuesAndReturnsBypassResult() throws Exception {
+        Map<String, Object> input = row("name", "新联系人");
+        input.put("id", 3); input.put("role", "003"); input.put("email", "demo@example.com");
+        input.put("telephone", "010-12345678"); input.put("mobileNumber", MASK);
+        when(reveal.reveal(anyString())).thenReturn("13800138000");
+        when(mapper.updateAddressBook(any(SensitiveAddressBookDemo.class))).thenReturn(1);
+        SensitiveAddressBookDemo saved = new SensitiveAddressBookDemo();
+        saved.setId(3L); saved.setRole("003"); saved.setMobileNumber(MASK);
+        when(mapper.queryAddressBookById(3L)).thenReturn(saved);
+
+        assertEquals(MASK, service.saveAddressBook(json.writeValueAsString(input)).get("mobileNumber"));
+        ArgumentCaptor<SensitiveAddressBookDemo> persisted = ArgumentCaptor.forClass(SensitiveAddressBookDemo.class);
+        verify(mapper).updateAddressBook(persisted.capture());
+        assertEquals("13800138000", persisted.getValue().getMobileNumber());
+        assertEquals("新联系人", persisted.getValue().getName());
+    }
+
+    @Test
+    public void expiredOrDamagedFragmentsNeverPersist() throws Exception {
+        when(reveal.reveal(anyString())).thenThrow(new SensitiveRevealService.ExpiredTokenException());
+        try { service.save(json.writeValueAsString(row("phoneNumber", MASK))); fail(); }
+        catch (SensitiveRevealService.ExpiredTokenException expected) { }
+        try { service.save(json.writeValueAsString(row("phoneNumber", "[#138****8000]"))); fail(); }
+        catch (IllegalArgumentException expected) { }
+        verifyZeroInteractions(mapper);
+    }
+
+    @Test
+    public void rejectsInvalidIdsAndOverlongResolvedContent() throws Exception {
+        for (Object id : new Object[]{0, -1, 1.5, "1"}) {
+            Map<String, Object> input = row("phoneNumber", "13800138000"); input.put("id", id);
+            try { service.save(json.writeValueAsString(input)); fail("accepted invalid id"); }
+            catch (IllegalArgumentException expected) { }
+        }
+        when(reveal.reveal(anyString())).thenReturn(new String(new char[65]).replace('\0', '1'));
+        try { service.save(json.writeValueAsString(row("phoneNumber", MASK))); fail(); }
+        catch (IllegalArgumentException expected) { }
+        verifyZeroInteractions(mapper);
+    }
+
+    private Map<String, Object> row(String key, String value) {
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("userId", "user-1"); result.put(key, value); return result;
+    }
+}

package/ark-control/src/test/java/com/union/control/service/sensitive/RedisRevealTokenStoreTest.java

@@ -0,0 +1,65 @@
+package com.union.control.service.sensitive;
+
+import com.nucc.channel.ark.common.redis.RedisCacheService;
+import com.nucc.channel.ark.common.util.ResultUtil;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class RedisRevealTokenStoreTest {
+    @Test
+    public void storesCiphertextThroughProductionRedisContract() {
+        RecordingRedis redis = new RecordingRedis();
+        RedisRevealTokenStore store = new RedisRevealTokenStore(redis, 300);
+
+        assertTrue(store.putAll(Arrays.asList(
+                new RedisRevealTokenStore.Entry("rt_A", "cipher-a"),
+                new RedisRevealTokenStore.Entry("rt_B", "cipher-b"))));
+        assertEquals(2, redis.values.size());
+        assertEquals(Integer.valueOf(300), redis.ttls.get(RedisRevealTokenStore.key("rt_A")));
+        assertEquals("cipher-a", store.get("rt_A"));
+    }
+
+    @Test
+    public void redisFailureDoesNotPublishRevealTokens() {
+        RecordingRedis redis = new RecordingRedis();
+        redis.failWrites = true;
+
+        assertFalse(new RedisRevealTokenStore(redis, 300).putAll(Arrays.asList(
+                new RedisRevealTokenStore.Entry("rt_A", "cipher-a"))));
+    }
+
+    @Test(expected = RedisRevealTokenStore.StoreUnavailableException.class)
+    public void redisReadFailureIsNotReportedAsAnExpiredToken() {
+        RecordingRedis redis = new RecordingRedis();
+        redis.failReads = true;
+
+        new RedisRevealTokenStore(redis, 300).get("rt_A");
+    }
+
+    static final class RecordingRedis extends RedisCacheService {
+        final Map<String, String> values = new HashMap<>();
+        final Map<String, Integer> ttls = new HashMap<>();
+        boolean failWrites;
+        boolean failReads;
+
+        @Override
+        public String setex(String key, int time, String value) {
+            if (failWrites) return ResultUtil.FAIL_RESULT;
+            values.put(key, value);
+            ttls.put(key, time);
+            return ResultUtil.SUCCESS_RESULT;
+        }
+
+        @Override
+        public String get(String key) {
+            return failReads ? ResultUtil.FAIL_RESULT : values.get(key);
+        }
+    }
+}

package/ark-control/src/test/java/com/union/control/service/sensitive/SensitiveRevealBoundaryTest.java

@@ -0,0 +1,99 @@
+package com.union.control.service.sensitive;
+
+import com.epcc.commons.securityproxy.api.SecurityResult;
+import com.epcc.commons.securityproxy.api.SymmetricalSecurityService;
+import com.epcc.dubbo.result.Result;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.nucc.channel.ark.common.exception.BaseDataErrorCode;
+import com.nucc.channel.ark.common.exception.CheckException;
+import com.nucc.channel.ark.common.redis.RedisCacheService;
+import com.union.control.mapper.interceptor.AESInterceptor;
+import com.union.control.utils.security.SymmetricalSecurityUtils;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
+
+import java.nio.charset.StandardCharsets;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public class SensitiveRevealBoundaryTest {
+    @Test
+    public void springSelectsTheSensitiveRevealProcessorProductionConstructor() {
+        java.lang.reflect.Constructor<?>[] constructors =
+                new AutowiredAnnotationBeanPostProcessor().determineCandidateConstructors(
+                        SensitiveRevealProcessor.class, "sensitiveRevealProcessor");
+
+        assertNotNull(constructors);
+        assertEquals(1, constructors.length);
+        assertEquals(2, constructors[0].getParameterTypes().length);
+    }
+
+    @Test
+    public void sensitiveInterceptorDependenciesAreRequired() throws Exception {
+        assertTrue(AESInterceptor.class.getDeclaredField("processor")
+                .getAnnotation(Autowired.class).required());
+        assertTrue(AESInterceptor.class.getDeclaredField("addressBook")
+                .getAnnotation(Autowired.class).required());
+    }
+
+    @Test
+    public void redisKeyContainsOnlyTheTokenHash() {
+        String token = "rt_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+        String key = RedisRevealTokenStore.key(token);
+        assertTrue(key.matches("sensitive:reveal:[0-9a-f]{64}"));
+        assertFalse(key.contains(token));
+    }
+
+    @Test
+    public void revealReturnsOnlyTheEncryptedFragment() throws Exception {
+        SymmetricalSecurityUtils crypto = new SymmetricalSecurityUtils(new PrefixGateway());
+        final String ciphertext = crypto.encryptWithCheck("13800138000");
+        RedisRevealTokenStore store = new RedisRevealTokenStore(new RedisCacheService() {
+            @Override
+            public String get(String key) {
+                return ciphertext;
+            }
+        }, 300);
+        String token = "rt_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
+
+        assertEquals("13800138000", new SensitiveRevealServiceImpl(store, crypto, new ObjectMapper())
+                .reveal("{\"userId\":\"ignored-by-first-version\",\"token\":\"" + token + "\"}"));
+    }
+
+    @Test(expected = SensitiveRevealService.InvalidTokenException.class)
+    public void malformedTokenNeverReachesTheStore() {
+        RedisRevealTokenStore store = new RedisRevealTokenStore(new RedisCacheService() {
+            @Override
+            public String get(String key) {
+                throw new AssertionError("store must not be called");
+            }
+        }, 300);
+        new SensitiveRevealServiceImpl(store,
+                new SymmetricalSecurityUtils(new PrefixGateway()), new ObjectMapper())
+                .reveal("{\"userId\":\"user-1\",\"token\":\"bad\"}");
+    }
+
+    static class PrefixGateway implements SymmetricalSecurityService {
+        @Override
+        public Result<SecurityResult> encryptByFixedKey(Algorithm algorithm, byte[] plaintext) {
+            byte[] prefix = "enc:".getBytes(StandardCharsets.UTF_8);
+            byte[] result = new byte[prefix.length + plaintext.length];
+            System.arraycopy(prefix, 0, result, 0, prefix.length);
+            System.arraycopy(plaintext, 0, result, prefix.length, plaintext.length);
+            return Result.success(new SecurityResult(result));
+        }
+
+        @Override
+        public Result<SecurityResult> decryptByFixedKey(Algorithm algorithm, byte[] ciphertext) {
+            if (ciphertext.length < 4) {
+                return Result.failure(BaseDataErrorCode.SYSTEM_INNER_ERROR.getCode(), "invalid");
+            }
+            return Result.success(new SecurityResult(
+                    java.util.Arrays.copyOfRange(ciphertext, 4, ciphertext.length)));
+        }
+    }
+}

package/ark-control/src/test/java/com/union/control/service/sensitive/SensitiveRevealProcessorCodecTest.java

@@ -0,0 +1,111 @@
+package com.union.control.service.sensitive;
+
+import com.epcc.commons.securityproxy.api.SecurityResult;
+import com.epcc.commons.securityproxy.api.SymmetricalSecurityService;
+import com.epcc.dubbo.result.Result;
+import com.nucc.channel.ark.common.annotation.EnDecryptField;
+import com.nucc.channel.ark.common.exception.BaseDataErrorCode;
+import com.nucc.channel.ark.common.exception.CheckException;
+import com.union.control.utils.security.SymmetricalSecurityUtils;
+import org.junit.Test;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+
+public class SensitiveRevealProcessorCodecTest {
+    @Test
+    public void encryptsEveryElementOfADirectListParameter() throws Exception {
+        SensitiveRevealProcessor codec = processor(new PrefixGateway());
+        List<Contact> contacts = new ArrayList<>();
+        contacts.add(new Contact("13800138000"));
+        contacts.add(new Contact("13900139000"));
+
+        codec.encrypt(contacts);
+
+        assertEquals(ciphertext("13800138000"), contacts.get(0).mobile);
+        assertEquals(ciphertext("13900139000"), contacts.get(1).mobile);
+    }
+
+    @Test
+    public void encryptsSensitiveKeysInAPlainMapParameter() throws Exception {
+        SensitiveRevealProcessor codec = processor(new PrefixGateway());
+        Map<String, Object> parameter = new HashMap<>();
+        parameter.put("email", "demo@example.com");
+        parameter.put("role", "001");
+
+        codec.encrypt(parameter);
+
+        assertEquals(ciphertext("demo@example.com"), parameter.get("email"));
+        assertEquals("001", parameter.get("role"));
+    }
+
+    @Test
+    public void keepsMyBatisScalarAliasesOnTheSameCiphertext() throws Exception {
+        SensitiveRevealProcessor codec = processor(new PrefixGateway());
+        Map<String, Object> parameter = new HashMap<>();
+        String email = new String("demo@example.com");
+        parameter.put("email", email);
+        parameter.put("param1", email);
+
+        codec.encrypt(parameter);
+
+        assertEquals(ciphertext("demo@example.com"), parameter.get("email"));
+        assertEquals(parameter.get("email"), parameter.get("param1"));
+    }
+
+    @Test(expected = CheckException.class)
+    public void encryptionFailureIsNotSwallowed() throws Exception {
+        SensitiveRevealProcessor codec = processor(new FailingGateway());
+        codec.encrypt(new Contact("13800138000"));
+    }
+
+    private static SensitiveRevealProcessor processor(SymmetricalSecurityService gateway) {
+        return new SensitiveRevealProcessor(new SymmetricalSecurityUtils(gateway), null);
+    }
+
+    private static String ciphertext(String plaintext) {
+        return Base64.getEncoder().encodeToString(
+                ("enc:" + plaintext).getBytes(StandardCharsets.UTF_8));
+    }
+
+    static class Contact {
+        @EnDecryptField
+        String mobile;
+
+        Contact(String mobile) {
+            this.mobile = mobile;
+        }
+    }
+
+    static class PrefixGateway implements SymmetricalSecurityService {
+        @Override
+        public Result<SecurityResult> encryptByFixedKey(Algorithm algorithm, byte[] plaintext) {
+            return Result.success(new SecurityResult(
+                    ("enc:" + new String(plaintext, StandardCharsets.UTF_8))
+                            .getBytes(StandardCharsets.UTF_8)));
+        }
+
+        @Override
+        public Result<SecurityResult> decryptByFixedKey(Algorithm algorithm, byte[] ciphertext) {
+            return Result.success(new SecurityResult(ciphertext));
+        }
+    }
+
+    static class FailingGateway implements SymmetricalSecurityService {
+        @Override
+        public Result<SecurityResult> encryptByFixedKey(Algorithm algorithm, byte[] plaintext) {
+            return Result.failure(BaseDataErrorCode.SYSTEM_INNER_ERROR.getCode(), "unavailable");
+        }
+
+        @Override
+        public Result<SecurityResult> decryptByFixedKey(Algorithm algorithm, byte[] ciphertext) {
+            return Result.failure(BaseDataErrorCode.SYSTEM_INNER_ERROR.getCode(), "unavailable");
+        }
+    }
+}

package/ark-control/src/test/java/com/union/control/service/sensitive/SensitiveRevealProcessorTest.java

@@ -0,0 +1,111 @@
+package com.union.control.service.sensitive;
+
+import com.epcc.commons.securityproxy.api.SecurityResult;
+import com.epcc.commons.securityproxy.api.SymmetricalSecurityService;
+import com.epcc.dubbo.result.Result;
+import com.nucc.channel.ark.common.exception.BaseDataErrorCode;
+import com.nucc.channel.ark.common.redis.RedisCacheService;
+import com.nucc.channel.ark.common.util.ResultUtil;
+import com.union.control.utils.security.SymmetricalSecurityUtils;
+import org.junit.Test;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class SensitiveRevealProcessorTest {
+    @Test
+    public void masksEachMatchAndWritesOneCiphertextBatch() throws Exception {
+        RecordingRedis redis = new RecordingRedis();
+        SymmetricalSecurityUtils crypto = new SymmetricalSecurityUtils(new PrefixGateway());
+        SensitiveRevealProcessor processor = new SensitiveRevealProcessor(
+                crypto, new RedisRevealTokenStore(redis, 300));
+        Map<String, Object> row = row(crypto, "手机13800138000，邮箱demo@example.com");
+
+        processor.process(row);
+
+        String value = (String) row.get("phoneNumber");
+        assertTrue(value, value.matches("手机\\[#138\\*{4}8000#VIEW:rt_[A-Za-z0-9_-]{43}\\]，"
+                + "邮箱\\[#d\\*{3}@example\\.com#VIEW:rt_[A-Za-z0-9_-]{43}\\]"));
+        assertEquals(2, redis.values.size());
+        assertTrue(redis.values.get(0).startsWith("ZW5j"));
+        assertFalse(redis.values.get(0).contains("13800138000"));
+    }
+
+    @Test
+    public void storeFailureReturnsMaskedValuesWithoutTokens() throws Exception {
+        RecordingRedis redis = new RecordingRedis();
+        redis.succeed = false;
+        SymmetricalSecurityUtils crypto = new SymmetricalSecurityUtils(new PrefixGateway());
+        SensitiveRevealProcessor processor = new SensitiveRevealProcessor(
+                crypto, new RedisRevealTokenStore(redis, 300));
+        Map<String, Object> row = row(crypto, "手机13800138000");
+
+        processor.process(row);
+
+        assertEquals("手机[#138****8000]", row.get("phoneNumber"));
+    }
+
+    @Test
+    public void fragmentEncryptionFailureNeverPublishesAnUnstoredToken() {
+        RecordingRedis redis = new RecordingRedis();
+        SensitiveRevealProcessor processor = new SensitiveRevealProcessor(
+                new SymmetricalSecurityUtils(new FailingEncryptGateway()),
+                new RedisRevealTokenStore(redis, 300));
+        Map<String, Object> row = new HashMap<>();
+        row.put("phoneNumber", Base64.getEncoder().encodeToString(
+                "enc:13800138000".getBytes(StandardCharsets.UTF_8)));
+
+        processor.process(row);
+
+        assertEquals("[#138****8000]", row.get("phoneNumber"));
+        assertTrue(redis.values.isEmpty());
+    }
+
+    private static Map<String, Object> row(SymmetricalSecurityUtils crypto, String plaintext)
+            throws Exception {
+        Map<String, Object> row = new HashMap<>();
+        row.put("phoneNumber", crypto.encryptWithCheck(plaintext));
+        return row;
+    }
+
+    static class RecordingRedis extends RedisCacheService {
+        boolean succeed = true;
+        final List<String> values = new ArrayList<>();
+
+        @Override
+        public String setex(String key, int time, String value) {
+            values.add(value);
+            return succeed ? ResultUtil.SUCCESS_RESULT : ResultUtil.FAIL_RESULT;
+        }
+    }
+
+    static class PrefixGateway implements SymmetricalSecurityService {
+        @Override
+        public Result<SecurityResult> encryptByFixedKey(Algorithm algorithm, byte[] plaintext) {
+            return Result.success(new SecurityResult(
+                    ("enc:" + new String(plaintext, StandardCharsets.UTF_8))
+                            .getBytes(StandardCharsets.UTF_8)));
+        }
+
+        @Override
+        public Result<SecurityResult> decryptByFixedKey(Algorithm algorithm, byte[] ciphertext) {
+            return Result.success(new SecurityResult(
+                    java.util.Arrays.copyOfRange(ciphertext, 4, ciphertext.length)));
+        }
+    }
+
+    static class FailingEncryptGateway extends PrefixGateway {
+        @Override
+        public Result<SecurityResult> encryptByFixedKey(Algorithm algorithm, byte[] plaintext) {
+            return Result.failure(BaseDataErrorCode.SYSTEM_INNER_ERROR.getCode(), "unavailable");
+        }
+    }
+}

package/ark-control/src/test/java/com/union/control/utils/security/SymmetricalSecurityUtilsCompatibilityTest.java

@@ -0,0 +1,87 @@
+package com.union.control.utils.security;
+
+import com.epcc.commons.securityproxy.api.SecurityResult;
+import com.epcc.commons.securityproxy.api.SymmetricalSecurityService;
+import com.epcc.dubbo.result.Result;
+import com.nucc.channel.ark.common.exception.CheckException;
+import org.junit.Test;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class SymmetricalSecurityUtilsCompatibilityTest {
+    @Test
+    public void longValuesUseTheConfiguredChunkSizeAndRoundTrip() throws Exception {
+        RecordingProxy proxy = new RecordingProxy();
+        SymmetricalSecurityUtils crypto = new SymmetricalSecurityUtils(proxy);
+
+        String ciphertext = crypto.encryptLongString("abcdefgh", 3);
+
+        assertEquals(3, proxy.encrypted.size());
+        assertEquals("abc", proxy.encrypted.get(0));
+        assertEquals("def", proxy.encrypted.get(1));
+        assertEquals("gh", proxy.encrypted.get(2));
+        assertEquals("abcdefgh", crypto.decryptLongString(ciphertext));
+    }
+
+    @Test
+    public void taggedValuesKeepTheProductionDatabaseMarkerDirection() throws Exception {
+        RecordingProxy proxy = new RecordingProxy();
+        SymmetricalSecurityUtils crypto = new SymmetricalSecurityUtils(proxy);
+        String plaintext = "手机13800138000 邮箱demo@example.com 电话010-12345678";
+
+        String ciphertext = crypto.encryptWithTag(plaintext);
+
+        assertTrue(ciphertext.contains("#["));
+        assertEquals(3, occurrences(ciphertext, "#["));
+        assertEquals(plaintext, crypto.decryptWithTag(ciphertext));
+    }
+
+    @Test
+    public void proxyFailureKeepsTheProductionCheckedErrorContract() {
+        SymmetricalSecurityUtils crypto = new SymmetricalSecurityUtils(new RecordingProxy() {
+            @Override
+            public Result<SecurityResult> encryptByFixedKey(Algorithm algorithm, byte[] plaintext) {
+                return Result.failure("REMOTE_ERROR", "unavailable");
+            }
+        });
+
+        try {
+            crypto.encryptWithCheck("13800138000");
+            throw new AssertionError("expected CheckException");
+        } catch (CheckException error) {
+            assertEquals("SYSTEM_INNER_ERROR", error.getCode());
+            assertTrue(error.getMessage().contains("REMOTE_ERROR"));
+        }
+    }
+
+    private static int occurrences(String value, String needle) {
+        return (value.length() - value.replace(needle, "").length()) / needle.length();
+    }
+
+    static class RecordingProxy implements SymmetricalSecurityService {
+        final List<String> encrypted = new ArrayList<>();
+
+        @Override
+        public Result<SecurityResult> encryptByFixedKey(Algorithm algorithm, byte[] plaintext) {
+            assertEquals(Algorithm.AES256, algorithm);
+            encrypted.add(new String(plaintext, StandardCharsets.UTF_8));
+            byte[] result = new byte[plaintext.length + 1];
+            result[0] = 42;
+            System.arraycopy(plaintext, 0, result, 1, plaintext.length);
+            return Result.success(new SecurityResult(result));
+        }
+
+        @Override
+        public Result<SecurityResult> decryptByFixedKey(Algorithm algorithm, byte[] ciphertext) {
+            assertEquals(Algorithm.AES256, algorithm);
+            byte[] result = new byte[ciphertext.length - 1];
+            System.arraycopy(ciphertext, 1, result, 0, result.length);
+            return Result.success(new SecurityResult(result));
+        }
+    }
+}

package/ark-control-facade/pom.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.union</groupId>
+    <artifactId>ark-control-facade</artifactId>
+    <version>1.0.0</version>
+    <packaging>jar</packaging>
+
+    <properties>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+</project>

package/ark-control-facade/src/main/java/com/union/control/service/AgentExecutionService.java

@@ -0,0 +1,8 @@
+package com.union.control.service;
+
+import java.util.Map;
+
+public interface AgentExecutionService {
+    Map<String, Object> claimAguiRun(String payload);
+    Map<String, Object> completeRun(String input);
+}

package/ark-control-facade/src/main/java/com/union/control/service/AgentProxyService.java

@@ -0,0 +1,7 @@
+package com.union.control.service;
+
+public interface AgentProxyService {
+    AgentResponse sync(String cookie, String payload);
+    AgentResponse scheduled(String authorization);
+    AgentResponse cancel(String cookie, String conversationId, String runId);
+}

package/ark-control-facade/src/main/java/com/union/control/service/AgentResponse.java

@@ -0,0 +1,22 @@
+package com.union.control.service;
+
+import java.io.Serializable;
+
+/** Serializable HTTP result carried by non-stream Agent Dubbo methods. */
+public final class AgentResponse implements Serializable {
+    private static final long serialVersionUID = 1L;
+    private int status;
+    private String body;
+
+    public AgentResponse() {}
+
+    public AgentResponse(int status, String body) {
+        this.status = status;
+        this.body = body;
+    }
+
+    public int getStatus() { return status; }
+    public void setStatus(int status) { this.status = status; }
+    public String getBody() { return body; }
+    public void setBody(String body) { this.body = body; }
+}

package/ark-control-facade/src/main/java/com/union/control/service/ConversationService.java

@@ -0,0 +1,12 @@
+package com.union.control.service;
+
+import java.util.Map;
+
+public interface ConversationService {
+    Map<String, Object> userInfo(String input);
+    Map<String, Object> conversations(String input);
+    Map<String, Object> conversation(String input);
+    Map<String, Object> conversationMessages(String input);
+    Map<String, Object> rename(String input);
+    Map<String, Object> deleteConversation(String input);
+}

package/ark-control-facade/src/main/java/com/union/control/service/MemoryStoreService.java

@@ -0,0 +1,12 @@
+package com.union.control.service;
+
+import java.util.Map;
+
+public interface MemoryStoreService {
+    Map<String, Object> memoryRead(String input);
+    Map<String, Object> memoryList(String input);
+    Map<String, Object> memoryOperation(String input);
+    Map<String, Object> memoryWrite(String input);
+    Map<String, Object> memoryDelete(String input);
+    Map<String, Object> memorySearch(String input);
+}

package/ark-control-facade/src/main/java/com/union/control/service/RunningAnalysisMockService.java

@@ -0,0 +1,10 @@
+package com.union.control.service;
+
+import java.util.Map;
+
+public interface RunningAnalysisMockService {
+    Map<String, Object> getOrgInfo(String input);
+    Map<String, Object> queryBigData(String input);
+    Map<String, Object> announceList(String input);
+    Map<String, Object> getJiraInfo(String input);
+}