Wie finde ich eine IP-Adresse, die in meinen Protokollen, aber nicht in meiner Amazon VPC enthalten ist?

Behebung

Hinweis: Wenn du beim Ausführen von AWS Command Line Interface (AWS CLI)-Befehlen Fehlermeldungen erhältst, findest du weitere Informationen dazu unter Problembehandlung bei der AWS CLI. Stelle außerdem sicher, dass du die neueste Version der AWS CLI verwendest.

CloudTrail-Ereignisse überprüfen

Gehe wie folgt vor, um mithilfe von AWS-CloudTrail-Ereignissen deine IP-Adresse zu ermitteln:

Um mithilfe des AllocateAddress-Ereignisses zu überprüfen, ob du dem AWS-Konto die Elastic IP-Adresse zugewiesen hast, führe den folgenden lookup-events-Befehl aus:

aws cloudtrail lookup-events \--region example-region \
--lookup-attributes AttributeKey=EventName,AttributeValue=AllocateAddress \
--start-time example-yyyy-mm-dd \
--query 'Events[].Resources[?ResourceName == 'example-eip-address'].{ResourceType:ResourceType,IP:ResourceName}[]' --output table

Hinweis: Ersetze example-eip-address durch deine Elastic IP-Adresse, example-yyyy-mm-dd durch dein Startdatum und example-region durch deine AWS-Region. Der vorherige CloudTrail-Befehl listet keine öffentlichen IPv4-Adressen von Amazon Elastic Compute Cloud (Amazon EC2) auf.

Um das AssociateAddress-Ereignis und die AllocationID-Filter zu verwenden, um den Service anzuzeigen, der die Elastic IP-Adresse verwendet, führe den folgenden lookup-events-Befehl aus:

aws cloudtrail lookup-events \--region example-region \
--lookup-attributes AttributeKey=ResourceName,AttributeValue=example-allocation-id \
--start-time example-yyyy-mm-dd \

Hinweis: Ersetze example-allocation-id durch deine Elastic IP-Adress-ID, example-yyyy-mm-dd durch dein Startdatum und example-region durch deine Region. Der vorherige Befehl zeigt den vollständigen Verlauf der Elastic IP-Adresszuweisung. Er beginnt mit der letzten und endet mit der frühesten Zuweisung basierend auf dem von dir ausgewählten Datum.

Um mithilfe des CreateNetworkInterface-Ereignisses zu überprüfen, ob du der Elastic-Network-Schnittstelle die private IP-Adresse zugewiesen hast, führe den folgenden lookup-events-Befehl aus:

aws cloudtrail lookup-events \--region example-region \
--lookup-attributes AttributeKey=EventName,AttributeValue=CreateNetworkInterface \
--start-time example-yyyy-mm-dd \
--query 'Events[].CloudTrailEvent' --output text | jq -r "select(.responseElements.networkInterface.privateIpAddressesSet.item[].privateIpAddress == \"example-private-ip-address\")"

Hinweis: Ersetze example-private-ip-address durch deine private IP-Adresse, example-yyyy-mm-dd durch dein Startdatum und example-region durch deine Region. Wenn der vorherige Befehl keine passenden Ereignisse zurückgibt, erhältst du keine Ausgabe.

Um mithilfe des AttachNetworkInterface-Ereignisses zu überprüfen, ob eine Ressource in der Vergangenheit eine Netzwerkschnittstelle verwendet hat, führe den folgenden lookup-events-Befehl aus:

aws cloudtrail lookup-events \--region example-region \
--lookup-attributes AttributeKey=EventName,AttributeValue=AttachNetworkInterface \
--start-time example-yyyy-mm-dd \
--query 'Events[].CloudTrailEvent' --output text | jq -r "select(.requestParameters.networkInterfaceId == \"example-eni-id\")"

Hinweis: Ersetze example-eni-id durch deine Netzwerkschnittstellen-ID, example-yyyy-mm-dd durch dein Startdatum und example-region durch deine Region.

Um zu überprüfen, ob CloudTrail die Ereignisse finden kann, führe den folgenden lookup-events-Befehl ohne den jq-Filter aus:

aws cloudtrail lookup-events \
--region example-region \
--lookup-attributes AttributeKey=EventName,AttributeValue=CreateNetworkInterface \
--start-time example-yyyy-mm-dd

Hinweis: Ersetze example-yyyy-mm-dd durch dein Startdatum und example-region durch deine Region.

Führe den folgenden lookup-events-Befehl aus, um mithilfe des RunInstances-Ereignisses zu überprüfen, ob du der Instance bei ihrem Start die private IP-Adresse zugeordnet hast:

aws cloudtrail lookup-events \--region example-region \
--lookup-attributes AttributeKey=EventName,AttributeValue=RunInstances \
--start-time example-yyyy-mm-dd \
--query 'Events[].CloudTrailEvent' --output text | jq -r "select(.responseElements.instancesSet.items[].privateIpAddress == \"example-private-ip-address\") | [.responseElements.instancesSet.items[].networkInterfaceSet.items[]] "

Hinweis: Ersetze example-private-ip-address durch deine private IP-Adresse, example-yyyy-mm-dd durch dein Startdatum und example-region durch deine Region.

Führe den folgenden lookup-events-Befehl aus, um mithilfe des AssignPrivateIpAddresses-Ereignisses zu überprüfen, ob du der Netzwerkschnittstelle die private IP-Adresse zugeordnet hast:

aws cloudtrail lookup-events \--region example-region \
--lookup-attributes AttributeKey=EventName,AttributeValue=AssignPrivateIpAddresses \
--start-time example-yyyy-mm-dd \
--query 'Events[].CloudTrailEvent' --output text | jq -r "select(.responseElements.assignedPrivateIpAddressesSet.assignedPrivateIpAddressSetType[].privateIpAddress == \"example-private-ip-address\" ) | {requestParameters,responseElements}"

Hinweis: Ersetze example-private-ip-address durch deine private IP-Adresse, example-yyyy-mm-dd durch dein Startdatum und example-region durch deine Region.

Führe den folgenden lookup-events-Befehl aus, um mithilfe des AssignIpv6Addresses-Ereignisses zu überprüfen, ob du der angegebenen Netzwerkschnittstelle die IPv6-Adresse zugeordnet hast:

aws cloudtrail lookup-events \--region example-region \
--lookup-attributes AttributeKey=EventName,AttributeValue=AssignIpv6Addresses \
--start-time example-yyyy-mm-dd \
--query 'Events[].CloudTrailEvent' --output text | jq -r "select(.responseElements.AssignIpv6AddressesResponse.assignedIpv6Addresses.item == \"example-IPv6-address\") | [.responseElements.AssignIpv6AddressesResponse] "

Hinweis: Ersetze example-IPv6-address durch deine IPv6-Adresse, example-yyyy-mm-dd durch dein Startdatum und example-region durch deine Region.

Verwendung der CloudWatch-Protokolle, um Protokolldaten zu analysieren

Hinweis: Konfiguriere deine Trail, um Protokollereignisse an Amazon CloudWatch Logs zu senden. Weitere Informationen findest du unter Überwachen von CloudTrail-Protokolldateien mit Amazon CloudWatch Logs.

Suche nach IPv4-Adressen, die deinem Konto zugewiesen sind

Verwende die folgenden Ereignisse, um die frühere Elastic IP-Adresszuweisung und den Service anzuzeigen, der die öffentliche IP-Adresse verwendet hat:

fields      eventTime as Time,
     userIdentity.accountId as AccountID,
     userIdentity.principalId as Principal,
     awsRegion as Region,
     eventName as Action,
     requestParameters.allocationId as AssociateAddress_AllocationID,
     requestParameters.instanceId as InstanceID,
     requestParameters.privateIpAddress as PrivateIP,
     responseElements.allocationId as AllocateAddress_AllocationID,
     responseElements.publicIp as EIP
| filter

     eventName = "AllocateAddress" or
     eventName = "AssociateAddress" and
     # AssociateAddress does not indicate resources outside EC2 instances.
     (
          EIP = "example-public-ip-addresses" or
          AssociateAddress_AllocationID = "example-allocation-id"
     )
| sort @timestamp desc

Hinweis: Ersetze example-public-ip-addresses durch deine öffentlichen IP-Adressen und example-allocation-id durch deine Zuordnungs-ID.

Verwende die folgenden Ereignisse, um die vorherigen privaten IP-Adresszuweisungen zu finden:

CreateNetworkInterface-Ereignis:

parse @message '"privateIpAddressesSet":{"item":[{"privateIpAddress":"*"' as PrivateIP| fields
eventTime as Time,
userIdentity.accountId as AccountID,
userIdentity.principalId as Principal,
awsRegion as Region,
eventName as Action,
responseElements.networkInterface.networkInterfaceId as ENI
| filter
eventName = "CreateNetworkInterface" and
(
PrivateIP = "example-private-ip-addresses"
)
| sort @timestamp desc

Hinweis: Ersetze example-private-ip-addresses durch deine IP-Adressen.

RunInstances-Ereignis:

parse @message '{"privateIpAddress":"*"' as PrivateIP|fields
     eventTime as Time,
     userIdentity.accountId as AccountID,
     userIdentity.principalId as Principal,
     awsRegion as Region,
     eventName as Action
| filter
     eventName = "RunInstances" and
     (
          PrivateIP = "example-private-ip-addresses"
     )
| sort @timestamp desc

Hinweis: Ersetze example-private-ip-addresses durch deine IP-Adressen.

AssignPrivateIpAddress-Ereignis:

parse @message '"assignedPrivateIpAddressSetType":[{*}]' as PrivateIpAddress| fields
     eventTime as Time,
     userIdentity.accountId as AccountID,
     userIdentity.principalId as Principal,
     awsRegion as Region,
     eventName as Action
| filter
     eventName = "AssignPrivateIpAddresses" and
     (
          PrivateIpAddress like "example-private-ip-addresses"
     )
| sort @timestamp desc

Note: Replace example-private-ip-addresses with your IP

Hinweis: Ersetze example-private-ip-addresses durch deine IP-Adressen.

Zeige die Ressourcen an, welche die Netzwerkschnittstelle verwendet haben:

fields      eventTime as Time,
     userIdentity.accountId as AccountID,
     userIdentity.principalId as Principal,
     awsRegion as Region,
     eventName as Action,
     requestParameters.instanceId as InstanceID,
     requestParameters.networkInterfaceId as ENI
| filter
     eventName = "AttachNetworkInterface" and
     (
          ENI = "example-eni-id"
     )
| sort @timestamp desc

Hinweis: Ersetze example-eni-id durch deine Netzwerkschnittstellen-ID.

Suche nach IPv6-Adressen, die deinem Konto zugewiesen sind

Verwende die folgenden Ereignisse, um die vorherigen privaten IP-Adresszuweisungen zu finden:

AssignIpv6Addresses-Ereignis:

fields    eventTime as Time,
    userIdentity.accountId as AccountID,
    userIdentity.principalId as Principal,
    awsRegion as Region,
    eventName as Action,
    responseElements.AssignIpv6AddressesResponse.assignedIpv6Addresses.item as IPv6
| filter
    eventName = "AssignIpv6Addresses" and
    (
        IPv6 = "example-ipv6-addresses"
    )
| sort @timestamp desc

Hinweis: Ersetze example-ipv6-addresses durch deine IP-Adressen.

RunInstances-Ereignis:

fields    eventTime as Time,
    userIdentity.accountId as AccountID,
    userIdentity.principalId as Principal,
    awsRegion as Region,
    eventName as Action,
    responseElements.AssignIpv6AddressesResponse.assignedIpv6Addresses.item as IPv6
| filter
    eventName = "RunInstances" and
    (
        PrivateIP = "example-private-ip-addresses"
    )
| sort @timestamp desc

Hinweis: Ersetze example-private-ip-addresses durch deine IP-Adressen.

CreateNetworkInterface-Ereignis:

parse @message '"ipv6AddressesSet":{"items":[{"ipv6Address":"*"' as IPv6| fields
     eventTime as Time,
     userIdentity.accountId as AccountID,
     userIdentity.principalId as Principal,
     awsRegion as Region,
     eventName as Action,
     responseElements.instancesSet.items.0.instanceId as InstanceID
| filter
     eventName = "CreateNetworkInterface" and
     (
         IPv6 = "example-ipv6-addresses"
     )
| sort @timestamp desc

Hinweis: Ersetze example-ipv6-addresses durch deine IP-Adressen.

Zeige die Ressourcen an, welche die Netzwerkschnittstelle verwendet haben:

fields      eventTime as Time,
     userIdentity.accountId as AccountID,
     userIdentity.principalId as Principal,
     awsRegion as Region,
     eventName as Action,
     requestParameters.instanceId as InstanceID,
     requestParameters.networkInterfaceId as ENI
| filter
     eventName = "AttachNetworkInterface" and
     (
         ENI = "example-eni-id" or
     )
| sort @timestamp desc

Hinweis: Ersetze example-eni-id durch deine Netzwerkschnittstellen-ID.

(Optional) Um zu überprüfen, ob das BGP-Präfix und die ASN der öffentlichen IP-Adresse eine AWS-IP-Adresse ist, führe den folgenden whois-Befehl aus:

whois -h whois.cymru.com " -v example-public-ip-address"

Hinweis: Ersetze example-public-ip-address durch deine öffentliche IP-Adresse.

Überprüfen des IP-Adressverlaufs

Du kannst eine ip-ranges.json-Datei, Amazon-VPC-IP Address Manager (IPAM) oder die AWS CLI verwenden, um eine IP-Adresse im IP-Adressverlauf zu finden.

ip-ranges.json

Führe die folgenden Schritte aus:

1. Eine Liste aller öffentlichen IP-Adressen, die zu einem AWS-Service gehören, findest du in der Datei ip-ranges.json.
2. Verwende die folgenden Variablen, um die Liste zu filtern:

   "ip_prefix"
   "region"
   "service"

IPAM

Gehe wie folgt vor, um mithilfe von IPAM die VPCs oder Ressourcen zu verfolgen, die im Laufe der Zeit eine bestimmte IP-Adresse verwendet haben:

1. Öffne die IPAM-Konsole.
2. Wähle im Navigationsbereich die Option IP-Verlauf durchsuchen aus.
3. Gib deine IP-Adresse ein.
4. Wähle Suche.

Die Suchergebnisse zeigen die folgenden Elemente:

• Die Netzwerkschnittstelle auswählen, die der IP-Adresse zugeordnet ist
• Zeitraum, in dem die IP-Adresse zugewiesen wurde
• Verwandte Ressourcen

AWS CLI

Um die AWS CLI zum Abrufen der IP-Adressinformationen zu verwenden, führe den folgenden Befehl get-ipam-address-history aus:

aws ec2 get-ipam-address-history \
 --ipam-scope-id ipam-scope-###### \
 --cidr 10.0.1.5 \
 --region us-east-1

Hinweis: Wenn du AWS Organizations verwendest, kannst du die Suche nach IP-Adressen auf Organisations-Ebene erweitern, um mehrere Mitgliedskonten zentral zu verfolgen.

Ein IPAM-Administratorkonto festlegen

Führe die folgenden Schritte aus:

1. Wähle in der Organisation ein AWS-Konto als Verwaltungskonto aus.
2. Um die Konto-ID zum IPAM-Administrator für deine Organisation zu machen, führe den folgenden Befehl enable-aws-service-access im Verwaltungskonto aus:

   aws organizations enable-aws-service-access \
    --service-principal ipam.amazonaws.comaws ec2 enable-ipam-organization-admin-account \
    --delegated-admin-account-id YOUR_ACCOUNT_ID

Hinweis: Ersetze YOUR_ACCOUNT_ID durch deine Konto-ID.

Einen IPAM im Administratorkonto erstellen

Führe die folgenden Schritte im IPAM-Administratorkonto aus:

1. Um einen IPAM zu erstellen, führe den folgenden create-ipam-Befehl aus:

   aws ec2 create-ipam \
    --description "Org-wide IPAM" \
    --operating-regions RegionName=us-east-1 RegionName=us-west-2

   Hinweis: Ersetze us-east-1 und us-west-2 durch deine Region.

   Dieser IPAM kann jetzt die CIDR-Nutzung über mehrere Konten hinweg erfassen und verwalten.

2. Führe den folgenden Befehl create-ipam-resource-discovery aus, um eine Ressourcenerkennung zu erstellen:

   aws ec2 create-ipam-resource-discovery \
   --description "Org-wide Discovery" \
   --operating-regions RegionName=us-east-1 \
   --tag-specifications ResourceType=ipam-resource-discovery,Tags=[{Key=Org,Value=Enabled}]

   Hinweis: Ersetze us-east-1 durch deine Region.

3. Um die Ressourcenerkennung mit IPAM zu verknüpfen, führe den folgenden Befehl associate-ipam-resource-discovery aus:

   aws ec2 associate-ipam-resource-discovery \
    --ipam-id ipam-######## \
    --ipam-resource-discovery-id ipam-res-disco-####

Du kannst eine Ressourcenerkennung mit einem anderen Konto teilen.

Hinweis: Jedes Mitgliedskonto in der Organisation muss Ressourcendaten mit dem IPAM teilen. Wenn du dieselbe Organisation verwendest und eine zentrale Erkennung eingerichtet hast, werden die Ressourcendaten automatisch geteilt. Verwende das IPAM-Dashboard, um erkannte Ressourcen wie VPCs und IP-Adressen zu überwachen.

Wichtig:

• Alle IP-Adressen, die du einem Konto oder einer VPC in der Organisation zuweist, werden im IP-Adressverlauf des IPAM angezeigt.
• Du kannst die IPAM-Konsole oder die AWS CLI verwenden, um die frühere Verwendung einer IP-Adresse abzufragen.
• Wenn die IP-Adresse im IPAM-Verlauf von AWS stammt und bösartige Aktivitäten vorliegen, melde den Missbrauch von AWS-Ressourcen.