OpenSSLで証明書を作ってAPI Gateway（REST API）にmTLS認証を実装してみた

OpenSSLで作成するもの
├── CA（認証局）の秘密鍵・証明書
├── サーバーの秘密鍵・証明書（CAで署名）
└── クライアントの秘密鍵・証明書（CAで署名）

# 秘密鍵
# Root CA の秘密鍵を生成します。これは最も重要な鍵であり、厳重に管理する必要があります。
openssl genrsa -out rootCA.key 4096

# 自己署名証明書(有効期限10年)
# 自分自身で署名する証明書を作成します。Root CA は上位の認証局を持たないため、自己署名となります。
openssl req -x509 -new -nodes \
  -key rootCA.key \
  -sha256 -days 3650 \
  -subj "/C=JP/O=StabOrg/OU=Security/CN=Stab Root CA" \
  -out rootCA.crt \
  -addext "basicConstraints=critical,CA:TRUE,pathlen:1" \
  -addext "keyUsage=critical,keyCertSign,cRLSign" \
  -addext "subjectKeyIdentifier=hash"

# 秘密鍵
openssl genrsa -out intCA.key 4096

# CSR（証明書署名要求）
# Root CA に「この内容で証明書を発行してください」と依頼するためのリクエストを作成
openssl req -new \
  -key intCA.key \
  -subj "/C=JP/O=StabOrg/OU=Security/CN=Stab Intermediate CA" \
  -out intCA.csr

# 拡張設定ファイル
# 署名時に付与する拡張属性を外部ファイルに定義します。
cat > intca.ext <<'EOF'
basicConstraints=critical,CA:TRUE,pathlen:0
keyUsage=critical,keyCertSign,cRLSign
subjectKeyIdentifier=hash
authorityKeyIdentifier=keyid,issuer
EOF

# Root CA で署名（有効期限 5年）
# Root CA の秘密鍵を使って、中間 CA の証明書を発行します。
openssl x509 -req \
  -in intCA.csr \
  -CA rootCA.crt -CAkey rootCA.key -CAcreateserial \
  -out intCA.crt \
  -days 1825 -sha256 \
  -extfile intca.ext

Root CA (pathlen:1)       ← 下に1階層の中間CAを許可
  └── 中間 CA (pathlen:0)  ← 下にCAを作ることは不可。クライアント証明書のみ署名可能
        └── クライアント証明書

# 秘密鍵（2048bit RSA、パスフレーズ付き）
# クライアントの秘密鍵を生成します。-aes256 を指定することで、パスフレーズで暗号化されます。
openssl genrsa -aes256 -out client.key 2048

# CSR
openssl req -new \
  -key client.key \
  -subj "/C=JP/O=StabOrg/OU=Clients/CN=stab-client-01" \
  -out client.csr

# 拡張設定ファイル
cat > client.ext <<'EOF'
basicConstraints=critical,CA:FALSE
keyUsage=critical,digitalSignature,keyEncipherment
extendedKeyUsage=critical,clientAuth
subjectKeyIdentifier=hash
authorityKeyIdentifier=keyid,issuer
EOF

# 中間 CA で署名
openssl x509 -req \
  -in client.csr \
  -CA intCA.crt -CAkey intCA.key -CAcreateserial \
  -out client.crt \
  -days 365 -sha256 \
  -extfile client.ext

truststore.pem の中身：
├── intCA.crt   ← クライアント証明書を直接署名したCA
└── rootCA.crt  ← 中間CAを署名したCA（信頼の起点）

cat intCA.crt rootCA.crt > truststore.pem

# チェーン検証
# クライアント証明書 → 中間CA → Root CA の信頼チェーンが正しいことを確認します。
# 「client.crt: OK」と表示されれば成功です。
openssl verify -CAfile rootCA.crt -untrusted intCA.crt client.crt
# clientAuth の確認
# クライアント証明書に clientAuth（クライアント認証）の拡張属性が付与されていることを確認します。
# 「TLS Web Client Authentication」と表示されれば正しく設定されています。
openssl x509 -in client.crt -noout -text | grep -A2 "Extended Key Usage"

mtls-apigw-cdk/
├── cdk.json
├── package.json              ← generate:truststore スクリプト
├── tsconfig.json
├── .gitignore                ← certs/*.pem を除外
├── .github/workflows/
│   └── deploy.yml
├── bin/
│   ├── app.ts                ← CDK エントリポイント
│   └── parameter.ts          ← ドメイン名などの設定値
├── certs/                    ← ランナー上で動的生成（Git 管理外）
├── lib/
│   ├── mtls-apigw-stack.ts   ← Stack
│   └── constructs/
│       ├── dns.ts            ← Route 53 ホストゾーン + ACM 証明書
│       ├── truststore.ts     ← S3 + BucketDeployment
│       ├── backend.ts        ← Lambda
│       └── mtls-api.ts       ← REST API + mTLS
└── lambda/
    └── index.ts

GitHub Environment Secrets
  │  TRUSTSTORE_PEM (intCA.crt + rootCA.crt の中身)
  │
  ▼
GitHub Actions ランナー
  │  npm run generate:truststore
  │  → echo "${TRUSTSTORE_PEM}" > certs/truststore.pem
  │
  ▼
cdk deploy
  │  BucketDeployment が certs/ を S3 にアップロード
  │
  ▼
S3 bucket
  └── truststore.pem → API Gateway が mTLS 検証に使用

"scripts": {
    "generate:truststore": "mkdir -p certs && echo \"${TRUSTSTORE_PEM}\" > certs/truststore.pem",
    "deploy": "cdk deploy --require-approval never"
  },

name: Deploy

on:
  workflow_dispatch:

permissions:
  id-token: write
  contents: read

jobs:
  deploy:
    runs-on: ubuntu-latest
    timeout-minutes: 30
    environment: DEVELOPMENT
    steps:
      - name: Checkout
        uses: actions/checkout@v6

      - name: Setup pnpm
        uses: pnpm/action-setup@v4
        with:
          version: 10

      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: "22"

      - name: Install dependencies
        run: pnpm install --frozen-lockfile

      - name: Generate truststore
        env:
          TRUSTSTORE_PEM: ${{ secrets.TRUSTSTORE_PEM }}
        run: pnpm run generate:truststore

      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: ${{ vars.AWS_ROLE_ARN }}
          aws-region: ap-northeast-1

      - name: Deploy
        run: pnpm run deploy

import { Construct } from "constructs";
import * as acm from "aws-cdk-lib/aws-certificatemanager";
import * as route53 from "aws-cdk-lib/aws-route53";
import * as route53Targets from "aws-cdk-lib/aws-route53-targets";
import * as apigateway from "aws-cdk-lib/aws-apigateway";

/**
 * DNS構成のプロパティ
 */
export interface DnsProps {
  parentHostedZoneName: string;
  domainName: string;
}

/**
 * DNS関連リソースを管理するConstruct
 */
export class Dns extends Construct {
  public readonly hostedZone: route53.IHostedZone;
  public readonly certificate: acm.ICertificate;

  constructor(scope: Construct, id: string, props: DnsProps) {
    super(scope, id);

    const { parentHostedZoneName, domainName } = props;

    /**
     * 親ホストゾーンを参照
     */
    const parentHostedZone = route53.HostedZone.fromLookup(
      this,
      "ParentHostedZone",
      {
        domainName: parentHostedZoneName,
      }
    );

    /**
     * サブドメイン用の新しいホストゾーンを作成
     */
    const hostedZone = new route53.HostedZone(this, "HostedZone", {
      zoneName: domainName,
    });

    /**
     * 親ホストゾーンにNS委任レコードを追加
     * これによりサブドメインのDNSクエリが新しいホストゾーンに委任される
     */
    new route53.ZoneDelegationRecord(this, "Delegation", {
      zone: parentHostedZone,
      recordName: domainName,
      nameServers: hostedZone.hostedZoneNameServers!,
    });

    /**
     * ACM証明書を作成（DNS検証）
     */
    const certificate = new acm.Certificate(this, "Certificate", {
      domainName,
      validation: acm.CertificateValidation.fromDns(hostedZone),
    });

    this.hostedZone = hostedZone;
    this.certificate = certificate;
  }

  /**
   * API GatewayへのAliasレコードを追加
   */
  public addApiRecord(restApi: apigateway.RestApi) {
    new route53.ARecord(this, "ApiAliasRecord", {
      zone: this.hostedZone,
      target: route53.RecordTarget.fromAlias(
        new route53Targets.ApiGateway(restApi)
      ),
    });
  }
}

import { Construct } from "constructs";
import * as cdk from "aws-cdk-lib";
import * as s3 from "aws-cdk-lib/aws-s3";
import * as s3deploy from "aws-cdk-lib/aws-s3-deployment";

export interface TruststoreProps {
  truststoreDir: string;
}

/**
 * mTLS用のTruststoreを管理するConstruct
 */
export class Truststore extends Construct {
  public readonly bucket: s3.IBucket;

  constructor(scope: Construct, id: string, props: TruststoreProps) {
    super(scope, id);

    const { truststoreDir } = props;

    /**
     * Truststore用S3バケット
     * バージョニング有効で証明書の変更履歴を保持
     */
    const bucket = new s3.Bucket(this, "Default", {
      encryption: s3.BucketEncryption.S3_MANAGED,
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: true,
      versioned: true,
    });

    /**
     * クライアント証明書をS3にデプロイ
     */
    new s3deploy.BucketDeployment(this, "Deploy", {
      sources: [s3deploy.Source.asset(truststoreDir)],
      destinationBucket: bucket,
      destinationKeyPrefix: "",
    });
    this.bucket = bucket;
  }
}

import { Construct } from "constructs";
import * as apigateway from "aws-cdk-lib/aws-apigateway";
import * as acm from "aws-cdk-lib/aws-certificatemanager";
import * as lambda from "aws-cdk-lib/aws-lambda";
import * as s3 from "aws-cdk-lib/aws-s3";

export interface MtlsApiProps {
  domainName: string;
  certificate: acm.ICertificate;
  truststoreBucket: s3.IBucket;
  handler: lambda.IFunction;
}

/**
 * mTLS対応のAPI Gatewayを管理するConstruct
 */
export class MtlsApi extends Construct {
  public readonly restApi: apigateway.RestApi;

  constructor(scope: Construct, id: string, props: MtlsApiProps) {
    super(scope, id);

    const { domainName, certificate, truststoreBucket, handler } = props;

    /**
     * mTLS対応のREST API
     * - カスタムドメインを使用
     * - デフォルトのexecute-apiエンドポイントは無効化
     */
    const restApi = new apigateway.RestApi(this, "RestApi", {
      restApiName: "mtls-api",
      description: "REST API with mTLS enabled (monolith Lambda)",
      deployOptions: {
        stageName: "v1",
      },
      disableExecuteApiEndpoint: true,
      domainName: {
        domainName,
        certificate,
        securityPolicy: apigateway.SecurityPolicy.TLS_1_2,
        mtls: {
          bucket: truststoreBucket,
          key: "truststore.pem",
        },
      },
    });

    /**
     * Lambda統合
     */
    const lambdaIntegration = new apigateway.LambdaIntegration(handler, {
      proxy: true,
    });

    /**
     * すべてのパスとメソッドをLambdaにルーティング
     */
    restApi.root.addMethod("ANY", lambdaIntegration);
    restApi.root.addProxy({
      defaultIntegration: lambdaIntegration,
      anyMethod: true,
    });

    this.restApi = restApi;
  }
}

import { Construct } from "constructs";
import * as cdk from "aws-cdk-lib";
import * as lambda from "aws-cdk-lib/aws-lambda";
import { NodejsFunction } from "aws-cdk-lib/aws-lambda-nodejs";
import * as path from "path";

/**
 * バックエンドLambda関数を管理するConstruct
 */
export class Backend extends Construct {
  public readonly handler: lambda.IFunction;

  constructor(scope: Construct, id: string) {
    super(scope, id);

    /**
     * API Gatewayからのリクエストを処理するLambda関数
     */
    this.handler = new NodejsFunction(this, "Handler", {
      runtime: lambda.Runtime.NODEJS_22_X,
      entry: path.join(__dirname, "../../lambda/index.ts"),
      handler: "handler",
      memorySize: 128,
      timeout: cdk.Duration.seconds(30),
    });
  }
}

import express from "express";
import serverlessExpress from "@codegenie/serverless-express";

const app = express();
app.use(express.json());

app.get("/health", (_req, res) => {
  res.json({ status: "ok" });
});

app.get("/", (_req, res) => {
  res.json({
    message: "mTLS authentication successful!",
  });
});

export const handler = serverlessExpress({ app });

curl -v --cert client.crt --key client.key https://<作成したドメイン>

certs %curl --cert client.crt --key client.key https://mtls.m2m-endpoint.com
Enter PEM pass phrase:
{"message":"mTLS authentication successful!"}%

curl -v https://<作成したドメイン>

certs %curl -v https://https://mtls.m2m-endpoint.com
* Could not resolve host: https
* Closing connection
curl: (6) Could not resolve host: https