Merge pull request iflytek#1163 from lyj715824/bugfix/superteam

fix: Extend model to add form field length

Author: yjlu666

PR.md

@@ -0,0 +1,3 @@
+ALTER TABLE `model`
+    MODIFY COLUMN `url` varchar(1024) DEFAULT NULL COMMENT 'Model call address',
+    MODIFY COLUMN `api_key` varchar(1024) DEFAULT NULL;

console/backend/hub/src/main/resources/db/migration/V1.25__expand_model_url_and_api_key_length.sql

@@ -2,15 +2,18 @@
 
 import com.iflytek.astron.console.toolkit.entity.vo.ModelCategoryReq;
 import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
 import lombok.Data;
 
 import java.util.List;
 
 @Data
 public class ModelValidationRequest {
     @NotNull(message = "Model endpoint cannot be empty")
+    @Size(max = 1024, message = "Model endpoint length cannot exceed 1024")
     private String endpoint;
     @NotNull(message = "API key cannot be empty")
+    @Size(max = 1024, message = "API key length cannot exceed 1024")
     private String apiKey;
     private String modelName;
     /**

console/backend/toolkit/src/main/java/com/iflytek/astron/console/toolkit/entity/biz/modelconfig/ModelValidationRequest.java

@@ -16,7 +16,6 @@ import {
   ConfigProvider,
   Switch,
 } from 'antd';
-import JSEncrypt from 'jsencrypt';
 import {
   modelCreate,
   deleteModelAPI,
@@ -55,6 +54,7 @@ import {
   normalizeModelProvider,
 } from '../utils/provider';
 import { mapProviderToVendor } from '../utils/provider-group';
+import { encryptApiKey } from '../utils/encrypt-api-key';
 
 const { TextArea } = Input;
 
@@ -64,16 +64,6 @@ const checkNameConventions = (string: string): boolean => {
   return regex.test(string);
 };
 
-const encryptApiKey = (publicKey: string, apiKey: string): string => {
-  const encrypt = new JSEncrypt();
-  encrypt.setPublicKey(publicKey);
-  const encrypted = encrypt.encrypt(apiKey);
-  if (!encrypted) {
-    throw new Error(i18next.t('model.encryptionFailed'));
-  }
-  return encrypted;
-};
-
 const checkParamsTable = (modelParams: ModelConfigParam[]): boolean => {
   let flag = true;
   modelParams.forEach(item => {
@@ -808,7 +798,7 @@ const ModelBasicForm = ({
               </div>
             </div>
             <Input
-              maxLength={255}
+              maxLength={1024}
               showCount
               placeholder={endpointPlaceholder}
               className="global-input w-full"
@@ -825,7 +815,7 @@ const ModelBasicForm = ({
               </div>
             </div>
             <Input
-              maxLength={255}
+              maxLength={1024}
               showCount
               placeholder={t('common.inputPlaceholder')}
               className="global-input w-full"

console/frontend/src/pages/model-management/components/modal-component.tsx

@@ -2,7 +2,6 @@ import { useState, useMemo, useCallback, JSX, Fragment } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useNavigate } from 'react-router-dom';
 import { Switch, message, Button } from 'antd';
-import JSEncrypt from 'jsencrypt';
 
 import { DeleteModal, CreateModal } from './modal-component';
 import StatusTag from './status-tag';
@@ -27,16 +26,15 @@ import i18next from 'i18next';
 import styles from './model-card.module.scss';
 import classNames from 'classnames';
 import { getModelProviderLabel } from '../utils/provider';
+import { encryptApiKey as encryptLongApiKey } from '../utils/encrypt-api-key';
 
 // 加密API密钥工具函数
 const encryptApiKey = (publicKey: string, apiKey: string): string => {
-  const encrypt = new JSEncrypt();
-  encrypt.setPublicKey(publicKey);
-  const encrypted = encrypt.encrypt(apiKey);
-  if (!encrypted) {
+  return encryptLongApiKey(publicKey, apiKey); /*
     throw new Error('API密钥加密失败');
   }
   return encrypted;
+*/
 };
 
 // 重新发布模型函数

console/frontend/src/pages/model-management/components/model-card.tsx

@@ -0,0 +1,105 @@
+import JSEncrypt from 'jsencrypt';
+import i18next from 'i18next';
+
+const RSA_PKCS1_PADDING_OVERHEAD = 11;
+const DEFAULT_MAX_CHUNK_BYTES = 245;
+
+const getMaxChunkBytes = (publicKey: string): number => {
+  const encrypt = new JSEncrypt();
+  encrypt.setPublicKey(publicKey);
+
+  const key = encrypt.getKey() as unknown as { n?: { bitLength?: () => number } };
+  const bitLength = key?.n?.bitLength?.();
+
+  if (typeof bitLength === 'number' && bitLength > RSA_PKCS1_PADDING_OVERHEAD) {
+    return Math.floor((bitLength + 7) / 8) - RSA_PKCS1_PADDING_OVERHEAD;
+  }
+
+  return DEFAULT_MAX_CHUNK_BYTES;
+};
+
+const splitTextByUtf8ByteLength = (
+  text: string,
+  maxChunkBytes: number
+): string[] => {
+  if (!text) {
+    return [''];
+  }
+
+  const encoder = new TextEncoder();
+  const chunks: string[] = [];
+  let currentChunk = '';
+  let currentChunkBytes = 0;
+
+  for (const char of text) {
+    const charBytes = encoder.encode(char).length;
+
+    if (charBytes > maxChunkBytes) {
+      throw new Error(i18next.t('model.encryptionFailed'));
+    }
+
+    if (currentChunkBytes + charBytes > maxChunkBytes) {
+      chunks.push(currentChunk);
+      currentChunk = char;
+      currentChunkBytes = charBytes;
+      continue;
+    }
+
+    currentChunk += char;
+    currentChunkBytes += charBytes;
+  }
+
+  if (currentChunk) {
+    chunks.push(currentChunk);
+  }
+
+  return chunks;
+};
+
+const decodeBase64ToBytes = (base64: string): Uint8Array => {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+
+  for (let i = 0; i < binary.length; i += 1) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+
+  return bytes;
+};
+
+const encodeBytesToBase64 = (bytes: Uint8Array): string => {
+  let binary = '';
+
+  for (let i = 0; i < bytes.length; i += 1) {
+    binary += String.fromCharCode(bytes[i] ?? 0);
+  }
+
+  return btoa(binary);
+};
+
+export const encryptApiKey = (publicKey: string, apiKey: string): string => {
+  const maxChunkBytes = getMaxChunkBytes(publicKey);
+  const chunks = splitTextByUtf8ByteLength(apiKey, maxChunkBytes);
+  const encrypt = new JSEncrypt();
+  encrypt.setPublicKey(publicKey);
+
+  const encryptedBlocks = chunks.map(chunk => {
+    const encrypted = encrypt.encrypt(chunk);
+    if (!encrypted) {
+      throw new Error(i18next.t('model.encryptionFailed'));
+    }
+
+    return decodeBase64ToBytes(encrypted);
+  });
+
+  const totalLength = encryptedBlocks.reduce((sum, block) => sum + block.length, 0);
+  const mergedBytes = new Uint8Array(totalLength);
+  let offset = 0;
+
+  encryptedBlocks.forEach(block => {
+    mergedBytes.set(block, offset);
+    offset += block.length;
+  });
+
+  return encodeBytesToBase64(mergedBytes);
+};