APIセキュリティリスクと対策：安全なデータ連携を実現するために

// Node.jsでのOAuth 2.0認証実装例（Express + Passport）
const express = require('express');
const passport = require('passport');
const OAuth2Strategy = require('passport-oauth2');

const app = express();

// OAuth 2.0の設定
passport.use(new OAuth2Strategy({
    authorizationURL: 'https://authorization-server.com/auth',
    tokenURL: 'https://authorization-server.com/token',
    clientID: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
    callbackURL: 'https://your-api.com/auth/callback'
  },
  function(accessToken, refreshToken, profile, cb) {
    // アクセストークンを検証し、ユーザー情報を取得
    // ...
    return cb(null, profile);
  }
));

// 認証ルート
app.get('/auth', passport.authenticate('oauth2'));

// コールバックルート
app.get('/auth/callback', 
  passport.authenticate('oauth2', { failureRedirect: '/login' }),
  function(req, res) {
    // 認証成功時の処理
    res.redirect('/');
  }
);

// 保護されたAPIエンドポイント
app.get('/api/protected-resource', 
  passport.authenticate('bearer', { session: false }),
  function(req, res) {
    res.json({ message: "This is a protected resource" });
  }
);

// JWTを使用したAPIアクセス制御の例
const express = require('express');
const jwt = require('jsonwebtoken');
const app = express();

// シークレットキー（環境変数から取得すべき）
const JWT_SECRET = process.env.JWT_SECRET;

// JWTトークン発行エンドポイント
app.post('/api/token', (req, res) => {
  // ユーザー認証（実際のアプリではデータベース検証など）
  const { username, password } = req.body;
  
  // 認証成功の場合
  if (isValidUser(username, password)) {
    // ペイロードの作成（最小限の情報のみ）
    const payload = {
      sub: userId,        // 件名（ユーザーID）
      name: username,     // ユーザー名
      role: userRole,     // 役割
      iat: Date.now(),    // 発行時刻
      exp: Date.now() + 3600000 // 有効期限（1時間）
    };
    
    // トークンの生成
    const token = jwt.sign(payload, JWT_SECRET, { 
      algorithm: 'HS256'  // アルゴリズム指定
    });
    
    res.json({ token });
  } else {
    res.status(401).json({ error: '認証失敗' });
  }
});

// JWTを検証するミドルウェア
function verifyToken(req, res, next) {
  const authHeader = req.headers.authorization;
  
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return res.status(401).json({ error: '認証トークンがありません' });
  }
  
  const token = authHeader.split(' ')[1];
  
  try {
    // トークンの検証
    const decoded = jwt.verify(token, JWT_SECRET);
    
    // リプレイ攻撃対策としてJTIの確認やトークンのブラックリスト確認などを行う
    
    // ユーザー情報をリクエストオブジェクトに追加
    req.user = decoded;
    next();
  } catch (err) {
    return res.status(403).json({ error: 'トークンが無効です' });
  }
}

// 保護されたエンドポイント
app.get('/api/protected', verifyToken, (req, res) => {
  res.json({ data: '保護されたデータ', user: req.user.name });
});

// Spring SecurityでのRBAC実装例
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/api/public/**").permitAll()
                .antMatchers("/api/users/**").hasRole("USER")
                .antMatchers("/api/admin/**").hasRole("ADMIN")
                .antMatchers(HttpMethod.POST, "/api/data").hasRole("EDITOR")
                .antMatchers(HttpMethod.PUT, "/api/data/**").hasRole("EDITOR")
                .antMatchers(HttpMethod.DELETE, "/api/data/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            .and()
            .oauth2ResourceServer()
                .jwt();
    }
}

// サービス層での細かい認可チェック
@Service
public class DataService {

    @PreAuthorize("hasRole('ADMIN') or @dataSecurityEvaluator.isOwner(authentication, #id)")
    public Data getDataById(Long id) {
        // データ取得ロジック
        return dataRepository.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException("Data not found"));
    }
}

// カスタム認可ロジック
@Component
public class DataSecurityEvaluator {
    
    private final DataRepository dataRepository;
    
    public DataSecurityEvaluator(DataRepository dataRepository) {
        this.dataRepository = dataRepository;
    }
    
    public boolean isOwner(Authentication authentication, Long dataId) {
        String username = authentication.getName();
        Data data = dataRepository.findById(dataId).orElse(null);
        return data != null && data.getOwner().equals(username);
    }
}

// エンティティクラス（データベースモデル）
@Entity
public class User {
    @Id
    private Long id;
    private String username;
    private String email;
    private String password; // センシティブ情報
    private String phoneNumber; // センシティブ情報
    private LocalDate birthDate;
    private String role;
    private LocalDateTime lastLogin;
    // getters and setters
}

// DTO（クライアントに返す情報のみを含む）
public class UserDTO {
    private Long id;
    private String username;
    private String email; // 用途によっては部分マスク
    private String role;
    // getters and setters
    
    // ユーザーエンティティからDTOを作成するファクトリメソッド
    public static UserDTO fromEntity(User user) {
        UserDTO dto = new UserDTO();
        dto.setId(user.getId());
        dto.setUsername(user.getUsername());
        // メールアドレスを部分的にマスク
        dto.setEmail(maskEmail(user.getEmail()));
        dto.setRole(user.getRole());
        return dto;
    }
    
    // メールアドレスのマスキング処理
    private static String maskEmail(String email) {
        if (email == null || email.isEmpty()) {
            return email;
        }
        String[] parts = email.split("@");
        if (parts.length != 2) {
            return email;
        }
        String name = parts[0];
        String domain = parts[1];
        if (name.length() <= 2) {
            return email;
        }
        return name.substring(0, 2) + "***@" + domain;
    }
}

// コントローラー
@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;
    
    @GetMapping("/{id}")
    public ResponseEntity<UserDTO> getUser(@PathVariable Long id) {
        User user = userService.findById(id);
        // エンティティをDTOに変換してから返す
        return ResponseEntity.ok(UserDTO.fromEntity(user));
    }
}

# Kongでのレート制限設定例
plugins:
- name: rate-limiting
  config:
    second: 5  # 1秒あたり5リクエスト
    minute: 100  # 1分あたり100リクエスト
    hour: 1000  # 1時間あたり1000リクエスト
    policy: local  # ストレージポリシー（local, redis, etc）
    limit_by: consumer  # 制限ベース（ip, credential, consumer）
    retry_after_jitter_max: 10  # リトライヘッダーのジッター最大値（秒）
    
# 異なるエンドポイントに異なる制限を設定
routes:
- name: api-public
  paths:
  - /api/public
  plugins:
  - name: rate-limiting
    config:
      minute: 300
      
- name: api-auth
  paths:
  - /api/auth
  plugins:
  - name: rate-limiting
    config:
      second: 3
      minute: 30
      
# 特定のコンシューマー（プレミアムユーザー）には高い制限を設定
consumers:
- username: premium-user
  plugins:
  - name: rate-limiting
    config:
      minute: 1000
      hour: 10000

// Redis + Node.jsでの分散レート制限の実装例
const express = require('express');
const redis = require('redis');
const { promisify } = require('util');

const app = express();
const client = redis.createClient({
  host: process.env.REDIS_HOST,
  port: process.env.REDIS_PORT,
  password: process.env.REDIS_PASSWORD
});

// Redisコマンドのプロミス化
const incrAsync = promisify(client.incr).bind(client);
const expireAsync = promisify(client.expire).bind(client);
const ttlAsync = promisify(client.ttl).bind(client);

// レート制限ミドルウェア
async function rateLimiter(req, res, next) {
  try {
    // ユーザーIDまたはIPアドレスをキーとして使用
    const key = req.user ? `rate:${req.user.id}` : `rate:${req.ip}`;
    
    // 現在の期間内のリクエスト数をインクリメント
    const requests = await incrAsync(key);
    
    // 最初のリクエストの場合は有効期限を設定
    if (requests === 1) {
      await expireAsync(key, 60); // 60秒（1分）の制限ウィンドウ
    }
    
    // 残り時間の取得
    const ttl = await ttlAsync(key);
    
    // ヘッダーに制限情報を設定
    res.setHeader('X-RateLimit-Limit', '100');
    res.setHeader('X-RateLimit-Remaining', Math.max(0, 100 - requests));
    res.setHeader('X-RateLimit-Reset', Date.now() + ttl * 1000);
    
    // 制限を超えた場合
    if (requests > 100) {
      return res.status(429).json({
        error: 'Too Many Requests',
        message: 'レート制限を超えました。しばらく待ってから再試行してください。',
        retryAfter: ttl
      });
    }
    
    next();
  } catch (err) {
    // Redisエラーが発生した場合でもAPIは動作させる
    console.error('Rate limiter error:', err);
    next();
  }
}

// APIルートにミドルウェアを適用
app.use('/api', rateLimiter);

// 保護されたエンドポイント
app.get('/api/data', (req, res) => {
  res.json({ message: 'Success' });
});

// Express + Joyを使用した入力バリデーション
const express = require('express');
const Joi = require('joi');
const app = express();

app.use(express.json());

// ユーザー作成APIのリクエストスキーマ
const userSchema = Joi.object({
  username: Joi.string().alphanum().min(3).max(30).required(),
  email: Joi.string().email().required(),
  password: Joi.string().pattern(
    new RegExp('^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#$%^&*])(?=.{8,})')
  ).required(),
  age: Joi.number().integer().min(18).max(120),
  role: Joi.string().valid('user', 'editor', 'admin')
});

// バリデーションミドルウェア
function validateRequest(schema) {
  return (req, res, next) => {
    const { error } = schema.validate(req.body);
    if (error) {
      return res.status(400).json({
        error: 'バリデーションエラー',
        details: error.details.map(x => x.message)
      });
    }
    next();
  };
}

// ユーザー作成API
app.post('/api/users', validateRequest(userSchema), (req, res) => {
  // バリデーション済みのデータでユーザーを作成
  // ...
  res.status(201).json({ message: 'ユーザーが作成されました' });
});

// パラメータ化クエリの例（Node.js + MySQL）
const mysql = require('mysql2/promise');

async function getUserData(userId) {
  const connection = await mysql.createConnection({
    host: 'localhost',
    user: 'user',
    password: 'password',
    database: 'mydb'
  });
  
  try {
    // 安全なパラメータ化クエリ
    const [rows] = await connection.execute(
      'SELECT id, username, email FROM users WHERE id = ?',
      [userId]
    );
    return rows[0];
  } finally {
    await connection.end();
  }
}

# Nginxでの安全なTLS設定例
server {
    listen 443 ssl http2;
    server_name api.dx-media.example;

    # 証明書の設定
    ssl_certificate /etc/nginx/ssl/api.dx-media.example.crt;
    ssl_certificate_key /etc/nginx/ssl/api.dx-media.example.key;
    
    # セッションキャッシュとチケットの設定
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    ssl_session_tickets off;
    
    # DHパラメータ（定期的に更新）
    ssl_dhparam /etc/nginx/ssl/dhparam.pem;
    
    # プロトコルと暗号スイートの設定
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256';
    
    # OCSPステープリングの有効化
    ssl_stapling on;
    ssl_stapling_verify on;
    resolver 8.8.8.8 8.8.4.4 valid=300s;
    resolver_timeout 5s;
    
    # HTTPセキュリティヘッダー
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload" always;
    add_header X-Content-Type-Options nosniff;
    add_header X-Frame-Options DENY;
    add_header X-XSS-Protection "1; mode=block";
    add_header Content-Security-Policy "default-src 'self'";
    
    # プロキシ設定
    location / {
        proxy_pass http://backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

# HTTPリクエストをHTTPSにリダイレクト
server {
    listen 80;
    server_name api.dx-media.example;
    return 301 https://$host$request_uri;
}

// Node.jsでの相互TLS認証の実装例
const https = require('https');
const fs = require('fs');
const express = require('express');

const app = express();

// HTTPSサーバーオプション（mTLS設定）
const options = {
  key: fs.readFileSync('/path/to/server-key.pem'),
  cert: fs.readFileSync('/path/to/server-cert.pem'),
  ca: fs.readFileSync('/path/to/ca-cert.pem'),
  requestCert: true,  // クライアント証明書を要求
  rejectUnauthorized: true  // 証明書検証に失敗した場合は拒否
};

app.get('/api/secure', (req, res) => {
  // クライアント証明書の情報を取得
  const cert = req.socket.getPeerCertificate();
  
  if (req.client.authorized) {
    res.json({
      message: '認証成功',
      client: cert.subject.CN,
      issuer: cert.issuer.CN
    });
  } else {
    res.status(401).json({
      error: '認証失敗',
      message: 'クライアント証明書が無効です'
    });
  }
});

// HTTPSサーバーの起動
https.createServer(options, app).listen(443, () => {
  console.log('mTLS対応APIサーバーが起動しました');
});

// クライアント側のmTLS実装例
function makeSecureRequest() {
  const options = {
    hostname: 'api.dx-media.example',
    port: 443,
    path: '/api/secure',
    method: 'GET',
    key: fs.readFileSync('/path/to/client-key.pem'),
    cert: fs.readFileSync('/path/to/client-cert.pem'),
    ca: fs.readFileSync('/path/to/ca-cert.pem')
  };

  const req = https.request(options, (res) => {
    console.log(`ステータスコード: ${res.statusCode}`);
    
    res.on('data', (chunk) => {
      console.log(`レスポンス: ${chunk}`);
    });
  });
  
  req.on('error', (e) => {
    console.error(`リクエストエラー: ${e.message}`);
  });
  
  req.end();
}

# AWS SAMテンプレートによるAPI Gateway設定例
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
  ApiGateway:
    Type: AWS::Serverless::Api
    Properties:
      StageName: prod
      Auth:
        DefaultAuthorizer: CognitoAuthorizer
        Authorizers:
          CognitoAuthorizer:
            UserPoolArn: !GetAtt UserPool.Arn
      GatewayResponses:
        DEFAULT_4XX:
          ResponseParameters:
            Headers:
              Access-Control-Allow-Origin: "'*'"
              Access-Control-Allow-Headers: "'Content-Type,X-Amz-Date,Authorization,X-Api-Key'"
      EndpointConfiguration: REGIONAL
      MethodSettings:
        - ResourcePath: '/*'
          HttpMethod: '*'
          ThrottlingBurstLimit: 100
          ThrottlingRateLimit: 50
          CachingEnabled: true
          CacheTtlInSeconds: 300
          LoggingLevel: INFO
      AccessLogSetting:
        DestinationArn: !GetAtt ApiAccessLogGroup.Arn
        Format: '{"requestId":"$context.requestId","ip":"$context.identity.sourceIp","caller":"$context.identity.caller","user":"$context.identity.user","requestTime":"$context.requestTime","httpMethod":"$context.httpMethod","resourcePath":"$context.resourcePath","status":"$context.status","protocol":"$context.protocol","responseLength":"$context.responseLength"}'
      
  UserPool:
    Type: AWS::Cognito::UserPool
    Properties:
      UserPoolName: api-users
      AutoVerifiedAttributes:
        - email
      PasswordPolicy:
        MinimumLength: 12
        RequireLowercase: true
        RequireNumbers: true
        RequireSymbols: true
        RequireUppercase: true
      MfaConfiguration: 'ON'
      
  ApiAccessLogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      RetentionInDays: 90
      
  ApiFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: index.handler
      Runtime: nodejs14.x
      Events:
        ApiEvent:
          Type: Api
          Properties:
            RestApiId: !Ref ApiGateway
            Path: /api/data
            Method: get
            Auth:
              Authorizer: CognitoAuthorizer

# API Security Testing with GitHub Actions
name: API Security Tests

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]
  schedule:
    - cron: '0 2 * * 1'  # 毎週月曜日の午前2時に実行

jobs:
  security-scan:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
        
      - name: Setup Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14'
          
      - name: Install dependencies
        run: npm ci
        
      - name: Static code analysis (ESLint security)
        run: npx eslint --ext .js,.ts --config .eslintrc.security.js src/
        
      - name: Dependency vulnerabilities check
        run: npm audit --audit-level=high
      
      - name: Run API integration tests
        run: npm test
          
      - name: API security scan with OWASP ZAP
        uses: zaproxy/action-baseline@v0.6.1
        with:
          target: 'https://staging-api.dx-media.example'
          rules_file_name: 'zap-rules.tsv'
          cmd_options: '-a'
          
      - name: API Contract Testing
        run: npm run contract-test
      
      - name: Upload security reports
        uses: actions/upload-artifact@v2
        with:
          name: security-reports
          path: |
            zap-report/
            reports/

# Elasticsearch APIセキュリティアラートの設定例
input {
  http {
    port => 8080
    codec => "json"
  }
  beats {
    port => 5044
  }
}

filter {
  if [type] == "api_access" {
    grok {
      match => { "message" => "%{COMBINEDAPACHELOG}" }
    }
    
    # リクエストレートの計算
    throttle {
      key => "%{clientip}"
      before_count => 50
      after_count => 1
      period => 60
      add_tag => "rate_limited"
    }
    
    # 401/403エラーの検出
    if [response] =~ /^4(0|1|3)$/ {
      mutate {
        add_field => { "auth_failure" => true }
      }
      
      # 同一IPからの連続認証失敗
      throttle {
        key => "%{clientip}-auth-failure"
        before_count => 5
        after_count => 1
        period => 300
        add_tag => "potential_brute_force"
      }
    }
    
    # 異常なパターンの検出
    if [request] =~ /\.(php|asp|aspx|jsp|exe|sh|pl|cgi)$/ {
      mutate {
        add_tag => "suspicious_request"
      }
    }
    
    # インジェクション攻撃の検出
    if [request] =~ /(\'|\"|\%27|\%22|\\)|(\%2527|\%2522)|(SELECT|INSERT|UPDATE|DELETE|DROP|UNION|OR|AND|WHERE|HAVING)/ {
      mutate {
        add_tag => "potential_injection"
      }
    }
  }
}

output {
  elasticsearch {
    hosts => ["elasticsearch:9200"]
    index => "api-logs-%{+YYYY.MM.dd}"
  }
  
  # 高リスクアラートをSlackに通知
  if "potential_brute_force" in [tags] or "potential_injection" in [tags] {
    http {
      url => "https://hooks.slack.com/services/XXXX/YYYY/ZZZZ"
      format => "json"
      content_type => "application/json"
      body => '{
        "channel": "#security-alerts",
        "username": "API Security Monitor",
        "text": "セキュリティアラート: %{tags}が検出されました。\nIP: %{clientip}\nRequest: %{request}",
        "icon_emoji": ":warning:"
      }'
    }
  }
}

# Istioを使用したゼロトラストAPI実装例
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: api-auth-policy
  namespace: default
spec:
  selector:
    matchLabels:
      app: api-service
  action: ALLOW
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/frontend-service"]
        namespaces: ["frontend"]
    - source:
        requestPrincipals: ["*@dx-media.example"]
    to:
    - operation:
        methods: ["GET"]
        paths: ["/api/public/*"]
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/admin-service"]
        namespaces: ["admin"]
    to:
    - operation:
        methods: ["GET", "POST", "PUT", "DELETE"]
        paths: ["/api/*"]
  - from:
    - source:
        requestPrincipals: ["*@dx-media.example"]
        notRequestPrincipals: ["test@dx-media.example"]
        properties:
          request.auth.claims[groups]: ["api-users"]
    to:
    - operation:
        methods: ["GET", "POST"]
        paths: ["/api/user/*"]
    when:
    - key: request.headers[x-api-version]
      values: ["v1", "v2"]
    - key: destination.labels[environment]
      values: ["prod"]
---
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: api-mtls
  namespace: default
spec:
  selector:
    matchLabels:
      app: api-service
  mtls:
    mode: STRICT
---
apiVersion: security.istio.io/v1beta1
kind: RequestAuthentication
metadata:
  name: api-jwt-auth
  namespace: default
spec:
  selector:
    matchLabels:
      app: api-service
  jwtRules:
  - issuer: "https://auth.dx-media.example"
    jwksUri: "https://auth.dx-media.example/.well-known/jwks.json"
    audiences: ["api.dx-media.example"]
    forwardOriginalToken: true
    outputPayloadToHeader: "x-jwt-payload"

## APIセキュリティ成熟度チェックリスト

### 基本的なセキュリティ
- [ ] すべてのAPIエンドポイントでTLSを強制
- [ ] 適切な認証メカニズムを実装（OAuth 2.0、APIキーなど）
- [ ] 基本的な入力バリデーションを実施
- [ ] APIドキュメントを整備
- [ ] センシティブデータの適切な処理

### 高度なセキュリティ
- [ ] レート制限と異常検知を実装
- [ ] APIゲートウェイを導入
- [ ] 適切なアクセス制御（RBAC/ABAC）を実装
- [ ] セキュリティテストを自動化
- [ ] インシデント対応プロセスを整備

### 最適化されたセキュリティ
- [ ] ゼロトラストアーキテクチャの導入
- [ ] コンテキストに基づく動的アクセス制御
- [ ] リアルタイム監視と自動応答
- [ ] 脅威インテリジェンスの活用
- [ ] API依存関係のセキュリティ管理