Разработка системы комиссий биржи

Разработка системы управления API-ключами

API-ключи — это программный аналог логина/пароля. Трейдер создаёт ключ с определёнными правами, передаёт боту или третьестороннему сервису, и тот торгует от его имени. Правильная система API-ключей — это гибкие разрешения, надёжное хранение и детальный audit log.

Модель данных API-ключей

type APIKey struct {
    ID          string    // публичный ключ (например: "ak_prod_a1b2c3d4...")
    Secret      string    // хэш секрета (NEVER хранить plain text)
    UserID      int64
    Label       string    // "Trading Bot", "Portfolio Tracker"
    
    // Разрешения
    Permissions APIPermissions
    
    // Ограничения
    IPWhitelist []string  // если пустой — любой IP
    ExpiresAt   *time.Time
    
    // Статус
    IsActive    bool
    LastUsedAt  *time.Time
    CreatedAt   time.Time
}

type APIPermissions struct {
    // Trading
    SpotTrade     bool
    MarginTrade   bool
    FuturesTrade  bool
    
    // Account
    ReadAccount   bool  // балансы, история
    Withdraw      bool  // ВНИМАНИЕ: высокий риск
    
    // Market Data
    ReadMarketData bool  // всегда включено для бесплатного доступа
}

Withdraw permission — самое опасное разрешение. Рекомендация: отдельное подтверждение при включении, отдельный whitelist адресов для этого ключа, уведомление на email.

Генерация и хранение ключей

import (
    "crypto/rand"
    "encoding/hex"
    "golang.org/x/crypto/bcrypt"
)

func GenerateAPIKey() (publicKey, secretKey string, err error) {
    // Public key: 32 байта, hex encoded
    pubBytes := make([]byte, 16)
    if _, err = rand.Read(pubBytes); err != nil {
        return
    }
    publicKey = "ak_" + hex.EncodeToString(pubBytes)
    
    // Secret: 32 байта, hex encoded
    secBytes := make([]byte, 32)
    if _, err = rand.Read(secBytes); err != nil {
        return
    }
    secretKey = hex.EncodeToString(secBytes)
    
    return
}

func HashSecret(secret string) (string, error) {
    // bcrypt для хранения — медленный hash, устойчив к brute force
    hash, err := bcrypt.GenerateFromPassword([]byte(secret), bcrypt.DefaultCost)
    return string(hash), err
}

func VerifySecret(secret, hash string) bool {
    return bcrypt.CompareHashAndPassword([]byte(hash), []byte(secret)) == nil
}

Критично: секретный ключ показывается пользователю ОДИН РАЗ при создании. В базе хранится только bcrypt хэш. Если пользователь потерял секрет — нужно создать новый ключ.

Middleware аутентификации

func APIKeyAuthMiddleware(db *DB) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            apiKeyID := r.Header.Get("X-API-Key")
            signature := r.Header.Get("X-Signature")
            timestamp := r.Header.Get("X-Timestamp")
            
            if apiKeyID == "" || signature == "" {
                writeError(w, 401, "Missing authentication headers")
                return
            }
            
            // 1. Находим ключ по public ID
            apiKey, err := db.GetAPIKey(apiKeyID)
            if err != nil || !apiKey.IsActive {
                writeError(w, 401, "Invalid API key")
                return
            }
            
            // 2. Timestamp проверка (анти-replay, ±5 сек)
            ts, _ := strconv.ParseInt(timestamp, 10, 64)
            if abs(time.Now().UnixMilli()-ts) > 5000 {
                writeError(w, 401, "Timestamp out of range")
                return
            }
            
            // 3. Верификация подписи (HMAC-SHA256)
            body, _ := io.ReadAll(r.Body)
            r.Body = io.NopCloser(bytes.NewBuffer(body))
            
            message := r.Method + r.URL.RequestURI() + timestamp + string(body)
            // Используем секрет из кэша (hash recovery невозможен — нужен отдельный cache)
            if !verifyHMAC(message, apiKey.SecretForVerification, signature) {
                writeError(w, 401, "Invalid signature")
                return
            }
            
            // 4. IP whitelist
            if len(apiKey.IPWhitelist) > 0 {
                clientIP := getClientIP(r)
                if !contains(apiKey.IPWhitelist, clientIP) {
                    writeError(w, 403, "IP not whitelisted")
                    return
                }
            }
            
            // 5. Обновляем last_used_at асинхронно
            go db.UpdateLastUsed(apiKey.ID)
            
            // Передаём контекст
            ctx := context.WithValue(r.Context(), "api_key", apiKey)
            next.ServeHTTP(w, r.WithContext(ctx))
        })
    }
}

Важное замечание: HMAC верификация требует знания секрета, но мы храним только bcrypt хэш. Решение: при создании ключа сохранять секрет в зашифрованном виде (AES-256 с ключом из HSM) только для HMAC верификации, не для показа пользователю повторно.

Permission checks

func RequirePermission(perm string) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            apiKey := r.Context().Value("api_key").(APIKey)
            
            hasPermission := false
            switch perm {
            case "spot_trade":
                hasPermission = apiKey.Permissions.SpotTrade
            case "withdraw":
                hasPermission = apiKey.Permissions.Withdraw
            case "read_account":
                hasPermission = apiKey.Permissions.ReadAccount
            }
            
            if !hasPermission {
                writeError(w, 403, fmt.Sprintf("Permission denied: %s required", perm))
                return
            }
            
            next.ServeHTTP(w, r)
        })
    }
}

// Использование:
router.POST("/api/v1/orders", 
    APIKeyAuthMiddleware(db),
    RequirePermission("spot_trade"),
    handler.PlaceOrder)

router.POST("/api/v1/withdrawals",
    APIKeyAuthMiddleware(db),
    RequirePermission("withdraw"),
    handler.CreateWithdrawal)

UI управления ключами

// Страница управления API ключами
function APIKeysManager() {
  const [keys, setKeys] = useState<APIKey[]>([]);
  const [showCreateModal, setShowCreateModal] = useState(false);
  
  return (
    <div>
      <Button onClick={() => setShowCreateModal(true)}>Create New API Key</Button>
      
      <table>
        {keys.map(key => (
          <tr key={key.id}>
            <td>{key.label}</td>
            <td><code>{key.id}</code></td>
            <td><PermissionBadges permissions={key.permissions} /></td>
            <td>{key.ipWhitelist.length > 0 ? key.ipWhitelist.join(', ') : 'All IPs'}</td>
            <td>{key.lastUsedAt ? formatRelative(key.lastUsedAt) : 'Never'}</td>
            <td>
              <ToggleButton active={key.isActive} onToggle={() => toggleKey(key.id)} />
              <DeleteButton onClick={() => deleteKey(key.id)} />
            </td>
          </tr>
        ))}
      </table>
      
      {showCreateModal && <CreateAPIKeyModal onCreated={handleKeyCreated} />}
    </div>
  );
}

// После создания — показываем секрет ОДИН РАЗ
function SecretRevealModal({ secret }: { secret: string }) {
  const [copied, setCopied] = useState(false);
  
  return (
    <Modal>
      <Alert type="warning">
        Скопируйте секретный ключ сейчас. Он больше не будет показан.
      </Alert>
      <CodeBlock value={secret} />
      <CopyButton value={secret} onCopy={() => setCopied(true)} />
      <Button disabled={!copied} onClick={closeModal}>
        Я скопировал ключ
      </Button>
    </Modal>
  );
}

Audit Log

Каждый API запрос логируется для безопасности:

CREATE TABLE api_access_log (
    id          BIGSERIAL PRIMARY KEY,
    api_key_id  VARCHAR(64) NOT NULL,
    user_id     BIGINT NOT NULL,
    method      VARCHAR(10) NOT NULL,
    path        VARCHAR(255) NOT NULL,
    ip_address  INET NOT NULL,
    status_code SMALLINT NOT NULL,
    latency_ms  INTEGER NOT NULL,
    created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
) PARTITION BY RANGE (created_at);

-- Хранить 90 дней, старое удалять
CREATE INDEX idx_api_log_key_time ON api_access_log(api_key_id, created_at DESC);

Разработка полной системы управления API-ключами с разрешениями, IP whitelist, audit log и UI: 3–4 недели.