Sécuriser les identifiants de base de données dans une fonction Lambda avec AWS Secrets Manager

# Ceci est une ressource de type Secret avec un mot de passe généré aléatoirement dans le champ SecretString du JSON 
MyRDSInstanceRotationSecret:
    Type: AWS::SecretsManager::Secret
    Properties:
    Description: 'This is my rds instance secret'
    GenerateSecretString:
        SecretStringTemplate: !Sub '{"username": "${!Ref RDSUserName}"}'
        GenerateStringKey: 'password'
        PasswordLength: 16
        ExcludeCharacters: '"@/\'
    Tags:
    -
        Key: AppNam
        Value: MyApp

# Ceci est une resource de type instance RDS. Le nom de l'utilisateur principal et le mot de passe utilisent des références dynamiques pour résoudre les valeurs
# depuis SecretsManager. La référence dynamique garantie que CloudFormation ne loggera pas ou ne persistera pas la valeur resolue 
# Nous utilisons "!Ref" pour référencer l'identifiant logique du Secret car le Secret est généré par CloudFormation
MyDBInstance2:
    Type: AWS::RDS::DBInstance
    Properties:
    AllocatedStorage: 20
    DBInstanceClass: db.t2.micro
    DBName: !Ref RDSDBName
    Engine: mysql
    MasterUsername: !Ref RDSUserName
    MasterUserPassword: !Join ['', ['{{resolve:secretsmanager:', !Ref MyRDSInstanceRotationSecret, ':SecretString:password}}' ]]
    MultiAZ: False
    PubliclyAccessible: False      
    StorageType: gp2
    DBSubnetGroupName: !Ref myDBSubnetGroup
    VPCSecurityGroups:
    - !Ref RDSSecurityGroup
    BackupRetentionPeriod: 0
    DBInstanceIdentifier: 'rotation-instance'

# Ceci permet de lier le secret et l'instance RDS 
SecretRDSInstanceAttachment:
    Type: AWS::SecretsManager::SecretTargetAttachment
    Properties:
    SecretId: !Ref MyRDSInstanceRotationSecret
    TargetId: !Ref MyDBInstance2
    TargetType: AWS::RDS::DBInstance

# Ceci permet de planifier la rotation. La rotation est effectuée par la lambda de rotation pour le Secret qui est référencé
# La première rotation est effectuée à la création de la resource. Les suivantes seront effectuées selon la planification configurée
# Cette resource est dépendante de la resource SecretRDSInstanceAttachment car la rotation a besoin que toutes les informations soient disponibles pour aboutir
MySecretRotationSchedule:
    Type: AWS::SecretsManager::RotationSchedule
    DependsOn: SecretRDSInstanceAttachment
    Properties:
    SecretId: !Ref MyRDSInstanceRotationSecret
    RotationLambdaARN: !GetAtt MyRotationLambda.Arn
    RotationRules:
        AutomaticallyAfterDays: 30

# Ceci est la lambda qui effectuera les rotations.
# Pour plus d'informations sur les rotations avec lambda, consultez :
# https://docs.thinkwithwp.com/fr_fr/secretsmanager/latest/userguide/rotating-secrets.html
# L'example suivant nécessite que le code de la lambda soit disponible dans un bucket S3
# et que la rotation se fasse pour une base mysql. 
MyRotationLambda:
    Type: AWS::Serverless::Function
    Properties:
    Runtime: python2.7
    Role: !GetAtt MyLambdaExecutionRole.Arn
    Handler: mysql_secret_rotation.lambda_handler
    Description: 'This is a lambda to rotate MySql user passwd'
    FunctionName: 'cfn-rotation-lambda'
    CodeUri: 's3://devsecopsblog/code.zip'      
    Environment:
        Variables:
        SECRETS_MANAGER_ENDPOINT: !Sub 'https://secretsmanager.${AWS::Region}.amazonaws.com' 

 import sys
    import pymysql
    import boto3
    import botocore
    import json
    import random
    import time
    import os
    from botocore.exceptions import ClientError
    
    # Paramètres RDS
    rds_host = os.environ['RDS_HOST']
    name = os.environ['RDS_USERNAME']
    db_name = os.environ['RDS_DB_NAME']
    helperFunctionARN = os.environ['HELPER_FUNCTION_ARN']
    
    secret_name = os.environ['SECRET_NAME']
    my_session = boto3.session.Session()
    region_name = my_session.region_name
    conn = None
    
    # Récupération de la ressource
    lambdaClient = boto3.client('lambda')
    
    
    def invokeConnCountManager(incrementCounter):
        # retourne True
        response = lambdaClient.invoke(
            FunctionName=helperFunctionARN,
            InvocationType='RequestResponse',
            Payload='{"incrementCounter":' + str.lower(str(incrementCounter)) + ',"RDBMSName": "Prod_MySQL"}'
        )
        retVal = response['Payload']
        retVal1 = retVal.read()
        return retVal1
    
    
    def openConnection():
        print("In Open connection")
        global conn
        password = "None"
        # Crée un client Secrets Manager 
        session = boto3.session.Session()
        client = session.client(
            service_name='secretsmanager',
            region_name=region_name
        )

        # Dans cet exemple, seuls les exceptions liées à l'appel API 'GetSecretValue' sont interceptés
        # Voir https://docs.thinkwithwp.com/fr_fr/secretsmanager/latest/apireference/API_GetSecretValue.html
        # Par défaut une exception en relancée
        
        try:
            get_secret_value_response = client.get_secret_value(
                SecretId=secret_name
            )
            print(get_secret_value_response)
        except ClientError as e:
            print(e)
            if e.response['Error']['Code'] == 'DecryptionFailureException':
                # Secrets Manager ne peut pas déchiffrer le texte protégé du secret avec la clé KMS proposée.
                # Vous pouvez gérer ce cas ici ou renvoyer cette exception à votre convenance
                raise e
            elif e.response['Error']['Code'] == 'InternalServiceErrorException':
                # Une erreur est survenue coté serveur
                # Vous pouvez gérer ce cas ici ou renvoyer cette exception à votre convenance
                raise e
            elif e.response['Error']['Code'] == 'InvalidParameterException':
                # Le paramètre fourni est invalide.
                # Vous pouvez gérer ce cas ici ou renvoyer cette exception à votre convenance
                raise e
            elif e.response['Error']['Code'] == 'InvalidRequestException':              
                # le paramètre fourni est invalide pour l'état actuel de la ressource
                # Vous pouvez gérer ce cas ici ou renvoyer cette exception à votre convenance
                raise e
            elif e.response['Error']['Code'] == 'ResourceNotFoundException':
                # La ressource demandée n'a pas été trouvée
                # Vous pouvez gérer ce cas ici ou renvoyer cette exception à votre convenance
                raise e
        else:
            # Déchiffre le secret avec la clé KMS associée
            # Selon le type "chaine de caractères" ou "binaire", un de ces champs sera rempli
            if 'SecretString' in get_secret_value_response:
                secret = get_secret_value_response['SecretString']
                j = json.loads(secret)
                password = j['password']
            else:
                decoded_binary_secret = base64.b64decode(get_secret_value_response['SecretBinary'])
                print("password binary:" + decoded_binary_secret)
                password = decoded_binary_secret.password    
        
        try:
            if(conn is None):
                conn = pymysql.connect(
                    rds_host, user=name, passwd=password, db=db_name, connect_timeout=5)
            elif (not conn.open):
                # print(conn.open)
                conn = pymysql.connect(
                    rds_host, user=name, passwd=password, db=db_name, connect_timeout=5)
    
        except Exception as e:
            print (e)
            print("ERROR: Unexpected error: Could not connect to MySql instance.")
            raise e
    
    
    def lambda_handler(event, context):
        if invokeConnCountManager(True) == "false":
            print ("Not enough Connections available.")
            return False
    
        item_count = 0
        try:
            openConnection()
            # Délai artificiel simulant une requête à la base de données. A supprimer pour une utilisation en conditions réelles
            time.sleep(random.randint(1, 3))
            with conn.cursor() as cur:
                cur.execute("select * from Employees")
                for row in cur:
                    item_count += 1
                    print(row)
                    # print(row)
        except Exception as e:
            # Erreur d'ouverture de connexion ou à l'execution
            print(e)
        finally:
            print("Closing Connection")
            if(conn is not None and conn.open):
                conn.close()
            invokeConnCountManager(False)
    
        content =  "Selected %d items from RDS MySQL table" % (item_count)
        response = {
            "statusCode": 200,
            "body": content,
            "headers": {
                'Content-Type': 'text/html',
            }
        }
        return response