#!/usr/local/bin/python3
""" Class and methods for interrogating AWS accounts for deployed services. """
import boto3
import botocore
from random import randint
from datetime import datetime, timedelta
import collections
from pprint import pprint
def nested_dict_iter(nested):
for key, value in nested.items():
if isinstance(value, collections.Mapping):
yield from nested_dict_iter(value)
else:
yield key, value
def printException(exceptionString: str, exceptionWriteString: str) -> set:
"""Write to variable for later s3 put."""
exceptionWriteString += exceptionString + '\n'
return exceptionWriteString
def assumeRoleSession(idNumber: str) -> set:
"""Create session with the assumed read only security role in the idNumber account."""
region = 'us-west-2'
client = boto3.client('sts')
role_arn = "arn:aws:iam::" + idNumber + ":role/Security-Readonly"
# Use the assertion to get an AWS STS token using Assume Role with SAML
client.get_session_token()
token = client.assume_role(RoleArn=role_arn,
RoleSessionName="AssumeRoleSession")
creds = token['Credentials']
session = boto3.Session(region_name=region,
aws_access_key_id=creds['AccessKeyId'],
aws_secret_access_key=creds['SecretAccessKey'],
aws_session_token=creds['SessionToken'])
return session
def createTable(dynamodb, tablename):
""" Initializes daily table to write entries. """
table = dynamodb.create_table(
TableName=tablename,
KeySchema=[
{
'AttributeName': 'accountID',
'KeyType': 'HASH'
},
{
'AttributeName': 'datetimekey',
'KeyType': 'RANGE'
}
],
AttributeDefinitions=[
{
'AttributeName': 'accountID',
'AttributeType': 'S'
},
{
'AttributeName': 'datetimekey',
'AttributeType': 'S'
}
],
ProvisionedThroughput={
'ReadCapacityUnits': 10,
'WriteCapacityUnits': 150,
}
)
return table
def destroyTable(dynamodb, tablename):
table = dynamodb.delete_table(
TableName=tablename
)
return True
def destroyWeekOldTable(dynamodb):
currentDate = datetime.now().today()
lastWeek = currentDate - timedelta(days=7)
thisWeekDB = 'awsAccountAudit-' + str(currentDate.strftime("%Y-%m-%d"))
lastWeekDB = 'awsAccountAudit-' + str(lastWeek.strftime("%Y-%m-%d"))
listDbs = dynamodb.list_tables()
# print('lastWeekDB: ', lastWeekDB)
# pprint(listDbs)
if lastWeekDB in listDbs['TableNames']:
try:
result = dynamodb.delete_table(TableName=lastWeekDB)
return result
except:
print('unable to delete table: ', lastWeekDB)
return False
def downShiftTable(dynamodb, tablename):
""" Reduces read / write capacity after the table is completed, to save costs. """
response = dynamodb.update_table(
TableName=tablename,
ProvisionedThroughput={
'ReadCapacityUnits': 10,
'WriteCapacityUnits': 10,
},
)
def writeDB(dynamodb, tablename, result):
tempDateTime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
for key in result:
nestedResult = nested_dict_iter(result[key])
for key1, value1 in nestedResult:
myDateTimeKey = tempDateTime + str(randint(0000, 9999))
if key1 == 'service':
service = value1
if key1 == 'region':
region = value1
if key1 == 'resourceID':
resourceID = value1
if key1 == 'accountID':
accountID = value1
if key1 == 'accountID':
accountID = value1
resourceData = str(result[key].get('resourceData')) # works as string 'S'
item = {
'accountID': {'S': accountID},
'datetimekey': {'S': myDateTimeKey},
'dateandtime:': {'S': tempDateTime},
'service': {'S': service},
'region': {'S': region},
'resourceID': {'S': resourceID},
'resourceData': {'S': resourceData}
}
dynamodb.put_item(
TableName=tablename,
Item=item
)
def getRegions(session: object) -> set:
"""Get list of regions from one account and set as global list."""
ec2 = session.client('ec2')
regions = ec2.describe_regions()
for region in regions['Regions']:
# pprint(region)
regions = [region['RegionName'] for region in ec2.describe_regions()['Regions']]
global count
count = len(regions)
return regions
class AwsAccount:
""" Initialize an account object to query available services. """
def __init__(self, session, id):
self.session = session
self.id = id
def returnSession(self):
return self.session
def returnID(self):
return self.id
# functions that return region specific results ----------------------------------
def ec2Services(self):
"""Get list of all deployed EC2 instances, including stopped."""
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
regionsLength = len(regions)
# print('regionsLength: ',regionsLength)
for x in range(0, len(regions)):
try:
region_name = regions[x]
# print('x = ', x)
ec2 = session.client('ec2', region_name=region_name)
# print('tested region: ', region_name)
instances = ec2.describe_instances()
for key in instances['Reservations']:
for instance in key['Instances']:
# print('tested instance in: ', region_name)
results[instance['InstanceId']] = {
'accountID': newID,
'resourceID': instance['InstanceId'],
'region': region_name,
'service': 'ec2.amazonaws.com',
'resourceData': instance
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
x += 1
return results
def publicIps(self):
"""Get list of all assigned public IPs"""
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
regionsLength = len(regions)
# print('regionsLength: ',regionsLength)
for x in range(0, len(regions)):
try:
region_name = regions[x]
# print('x = ', x)
ec2 = session.client('ec2', region_name=region_name)
response = ec2.describe_network_interfaces(Filters=[{'Name':'addresses.association.public-ip', 'Values':['*']}])
for interface in response['NetworkInterfaces']:
results[interface['Association']['PublicIp']] = {
'accountID': newID,
'resourceID': interface['Association']['PublicIp'],
'region': region_name,
'service': 'ec2.amazonaws.com',
'resourceData': interface
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
x += 1
return results
def vpcServices(self):
"""Get list of all VPCs in all accounts."""
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
# print(region_name)
ec2 = session.client('ec2', region_name=region_name)
vpc = ec2.describe_vpcs()
try:
for vpc in vpc['Vpcs']:
results[vpc['VpcId']] = {
'accountID': newID,
'resourceID': vpc['VpcId'],
'region': region_name,
'service': 'vpc.amazonaws.com',
'resourceData': vpc
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def elbServices(self):
""" Method to list all deployed load balancers. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
# print(region_name)
elb = session.client('elb', region_name=region_name)
response = elb.describe_load_balancers()
try:
for x in response['LoadBalancerDescriptions']:
results[x['LoadBalancerName']] = {
'accountID': newID,
'resourceID': x['LoadBalancerName'],
'region': region_name,
'service': 'elb.amazonaws.com',
'resourceData': response['LoadBalancerDescriptions'],
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def configServices(self):
""" Pull config rule names for all regions. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
config = session.client('config', region_name=region_name)
try:
response = config.describe_compliance_by_config_rule()
for item in response['ComplianceByConfigRules']:
results[item['ConfigRuleName']] = {
'accountID': newID,
'resourceID': item['ConfigRuleName'],
'region': region_name,
'service': 'config.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def snsServices(self):
""" List all sns topics in all regions. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
sns = session.client('sns', region_name=region_name)
try:
response = sns.list_topics()
# print('fetching sns topics for acct: ', newID)
for item in response['Topics']:
results[item['TopicArn']] = {
'accountID': newID,
'resourceID': item['TopicArn'],
'region': region_name,
'service': 'sns.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def codedeployServices(self):
""" List all applications in all regions. Useful for identifying necessary app logs. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for x in range(0, len(regions)):
try:
region_name = regions[x]
codedeploy = session.client('codedeploy', region_name=region_name)
response = codedeploy.list_applications()
# pprint(response)
for item in response['applications']:
results[item] = {
'accountID': newID,
'resourceID': item,
'region': region_name,
'service': 'codedeploy.amazonaws.com',
'resourceData': 'null', # response['applications'][item].get('resourceData'),
}
# print(results)
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def cloudfrontServices(self):
""" List all cloudfront distributions. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
cloudfront = session.client('cloudfront', region_name=region_name)
try:
response = cloudfront.list_distributions()
#results = response
for x in response['DistributionList']['Items']:
results[x['Id']] = {
'accountID': newID,
'resourceID': x['Id'],
'region': region_name,
'service': 'cloudfront.amazonaws.com',
'resourceData': x,
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def acmServices(self):
""" List all certificates in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
acm = session.client('acm', region_name=region_name)
try:
response = acm.list_certificates()
for item in response['CertificateSummaryList']:
results[item['CertificateArn']] = {
'accountID': newID,
'resourceID': item['CertificateArn'],
'region': region_name,
'service': 'acm.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def cloudtrailServices(self):
""" List all cloudtrails in all regions. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
cloudtrail = session.client('cloudtrail', region_name=region_name)
try:
response = cloudtrail.describe_trails()
for item in response['trailList']:
results[item['Name']] = {
'accountID': newID,
'resourceID': item['Name'],
'region': region_name,
'service': 'cloudtrail.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def elasticacheServices(self):
""" List all cache clusters in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
elasticache = session.client('elasticache', region_name=region_name)
try:
response = elasticache.describe_cache_clusters()
for x in response['CacheClusters']:
results[x['CacheClusterId']] = {
'accountID': newID,
'resourceID': x['CacheClusterId'],
'region': region_name,
'service': 'elasticache.amazonaws.com',
'resourceData': x,
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def kmsServices(self):
""" List all customer encryption keys in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
kms = session.client('kms', region_name=region_name)
try:
response = kms.list_keys()
for item in response['Keys']:
results[item['KeyId']] = {
'accountID': newID,
'resourceID': item['KeyId'],
'region': region_name,
'service': 'kms.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def lambdaServices(self):
""" List all lambda functions in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
lambdaFunctions = session.client('lambda', region_name=region_name)
try:
response = lambdaFunctions.list_functions()
for item in response['Functions']:
results[item['FunctionName']] = {
'accountID': newID,
'resourceID': item['FunctionName'],
'region': region_name,
'service': 'lambda.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def dynamodbServices(self):
""" List all tables in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
ddb = session.client('dynamodb', region_name=region_name)
response = ddb.list_tables()
try:
for x in response['TableNames']:
results[x] = {
'accountID': newID,
'resourceID': x,
'region': region_name,
'service': 'dynamodb.amazonaws.com',
'resourceData': x
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def efsServices(self):
""" List all Elastice File Systems (NFS) in each region """
session = self.session
newID = self.id
# overriding region due to limited offerings, avoid connection failure error
regions = ['us-east-1','us-east-2','us-west-1','us-west-2','eu-west-1','eu-west-1','eu-central-1','ap-southeast-2','ap-northeast-2']
results = {}
for region_name in regions:
efs = session.client('efs', region_name=region_name)
try:
response = efs.describe_file_systems()
for x in response['FileSystems']:
# pprint(x)
results[x['Name']] = {
'accountID': newID,
'resourceID': x['Name'],
'region': region_name,
'service': 'elasticfilesystem.amazonaws.com',
'resourceData': x,
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def autoscalingServices(self):
""" List all autoscaling groups in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
autoscaling = session.client('autoscaling', region_name=region_name)
try:
response = autoscaling.describe_auto_scaling_groups()
for x in response['AutoScalingGroups']:
# pprint(x)
results[x['AutoScalingGroupName']] = {
'accountID': newID,
'resourceID': x['AutoScalingGroupName'],
'region': region_name,
'service': 'autoscaling.amazonaws.com',
'resourceData': x,
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def cloudformationServices(self):
""" List all stacks loaded in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
cloudformation = session.client('cloudformation', region_name=region_name)
try:
response = cloudformation.describe_stacks(StackStatusFilter=['CREATE_COMPLETE','UPDATE_COMPLETE'])
for item in response['Stacks']:
results[item['StackName']] = {
'accountID': newID,
'resourceID': item['StackName'],
'region': region_name,
'service': 'cloudformation.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def rdsServices(self):
""" List all database instances in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
rds= session.client('rds', region_name=region_name)
try:
response = rds.describe_db_instances()
for item in response['DBInstances']:
results[item['DBName']]={
'accountID': newID,
'resourceID': item['DBName'],
'region': region_name,
'service': 'rds.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def elbv2Services(self):
""" List all v2 elbs in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
elbv2= session.client('elbv2', region_name=region_name)
try:
response = elbv2.describe_load_balancers()
for item in response['LoadBalancers']:
results[item['LoadBalancerName']]={
'accountID': newID,
'resourceID': item['LoadBalancerName'],
'region': region_name,
'service': 'elbv2.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def ebsServices(self):
""" List all elastic beanstalk environments in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
ebs= session.client('ebs', region_name=region_name)
try:
response = ebs.describe_environments()
for item in response['Environments']:
results[item['ApplicationName']]={
'accountID': newID,
'resourceID': item['ApplicationName'],
'region': region_name,
'service': 'ebs.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def lightsailServices(self):
""" List all lightsail deployments in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
lightsail= session.client('lightsail', region_name=region_name)
try:
response = lightsail.get_instances()
for item in response['instances']:
results[item['name']]={
'accountID': newID,
'resourceID': item['name'],
'region': region_name,
'service': 'lightsail.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def emrServices(self):
""" List all elastic map reduce deployments in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
emr = session.client('emr', region_name=region_name)
try:
response = emr.list_clusters()
for item in response['Clusters']:
results[item['Name']]={
'accountID': newID,
'resourceID': item['Name'],
'region': region_name,
'service': 'elasticmapreduce.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def workspacesServices(self):
""" List all workspace deployments in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
workspaces = session.client('workspaces', region_name=region_name)
try:
response = workspaces.list_clusters()
for item in response['Workspaces']:
results[item['ComputerName']]={
'accountID': newID,
'resourceID': item['ComputerName'],
'region': region_name,
'service': 'workspaces.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def guarddutyServices(self):
""" List all guard duty detectors in each region. TODO Need to get findings. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
guardduty = session.client('guardduty', region_name=region_name)
try:
response = guardduty.list_detectors()
for item in response['DetectorIds']:
results[item]={
'accountID': newID,
'resourceID': item,
'region': region_name,
'service': 'guardduty.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def redshiftServices(self):
""" List all redshift deployments in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
redshift = session.client('redshift', region_name=region_name)
try:
response = redshift.describe_clusters()
for item in response['Clusters']:
results[item['DBName']]={
'accountID': newID,
'resourceID': item['DBName'],
'region': region_name,
'service': 'redshift.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def elasticsearchServices(self):
""" List all elasticsearch deployments in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
es = session.client('es', region_name=region_name)
try:
response = es.list_domain_names()
for item in response['DomainNames']:
results[item]={
'accountID': newID,
'resourceID': item,
'region': region_name,
'service': 'es.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def firehoseServices(self):
""" List all firehose in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
firehose = session.client('firehose', region_name=region_name)
try:
response = firehose.list_delivery_streams()
for item in response['DeliveryStreamNames']:
results[item]={
'accountID': newID,
'resourceID': item,
'region': region_name,
'service': 'firehose.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def kinesisServices(self):
""" List all firehose in each region. """
session = self.session
newID = self.id
regions = getRegions(session)
results = {}
for region_name in regions:
kinesis = session.client('kinesis', region_name=region_name)
try:
response = kinesis.list_streams()
for item in response['StreamNames']:
results[item]={
'accountID': newID,
'resourceID': item,
'region': region_name,
'service': 'kinesis.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
# functions that return global results--------------------------------------------
def route53Services(self):
""" List all hosted zones. """
session = self.session
newID = self.id
route53 = session.client('route53')
results = {}
try:
response = route53.list_hosted_zones()
for item in response['HostedZones']:
results[item['Name']] = {
'accountID': newID,
'resourceID': item['Name'],
'region': 'global',
'service': 'route53.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def s3Services(self):
""" List all s3 buckets. TODO Needs to be improved to add region. """
session = self.session
newID = self.id
s3 = session.client('s3')
results = {}
try:
buckets = s3.list_buckets()
for x in buckets['Buckets']:
results[x['Name']] = {
'accountID': newID,
'resourceID': x['Name'],
'region': 'global',
'service': 's3.amazonaws.com',
'resourceData': x,
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def cloudwatchServices(self):
""" List all dashboards. """
session = self.session
newID = self.id
cloudwatch = session.client('cloudwatch')
results = {}
try:
response = cloudwatch.list_dashboards()
for item in response['DashboardEntries']:
results[item['DashboardName']] = {
'accountID': newID,
'resourceID': item['DashboardName'],
'region': 'global',
'service': 'cloudwatch.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def iamServices(self):
""" List all iam users in the account. """
session = self.session
newID = self.id
iam = session.client('iam')
results = {}
try:
response = iam.list_users()
for item in response['Users']:
results[item['UserName']] = {
'accountID': newID,
'resourceID': item['UserName'],
'region': 'global',
'service': 'iam.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results
def shieldServices(self):
""" List all shield deployments in the account. """
session = self.session
newID = self.id
shield = session.client('shield')
results = {}
try:
response = shield.list_attacks()
for item in response['AttackSummaries']:
results[item['AttackId']] = {
'accountID': newID,
'resourceID': item['AttackId'],
'region': 'global',
'service': 'shield.amazonaws.com',
'resourceData': item
}
except botocore.exceptions.ClientError as error:
exceptionString = 'account id: ' + newID + ' error: {0}'.format(error) + '\n'
print(exceptionString)
return results