Serverless.com Sicherheit

Reading time: 18 minutes

Grundinformationen

Organisation

Eine Organisation ist die höchste Ebene innerhalb des Serverless Framework-Ökosystems. Sie repräsentiert eine kollektive Gruppe, wie ein Unternehmen, eine Abteilung oder eine große Einheit, die mehrere Projekte, Teams und Anwendungen umfasst.

Team

Das Team sind die Benutzer mit Zugang innerhalb der Organisation. Teams helfen dabei, Mitglieder basierend auf Rollen zu organisieren. Mitarbeiter können bestehende Apps anzeigen und bereitstellen, während Administratoren neue Apps erstellen und die Einstellungen der Organisation verwalten können.

Anwendung

Eine App ist eine logische Gruppierung verwandter Dienste innerhalb einer Organisation. Sie repräsentiert eine vollständige Anwendung, die aus mehreren serverlosen Diensten besteht, die zusammenarbeiten, um eine kohärente Funktionalität bereitzustellen.

Dienste

Ein Dienst ist die zentrale Komponente einer Serverless-Anwendung. Er repräsentiert Ihr gesamtes serverloses Projekt und umfasst alle Funktionen, Konfigurationen und Ressourcen, die benötigt werden. Er wird typischerweise in einer serverless.yml-Datei definiert, ein Dienst enthält Metadaten wie den Dienstnamen, Anbieter-Konfigurationen, Funktionen, Ereignisse, Ressourcen, Plugins und benutzerdefinierte Variablen.

service: my-service
provider:
name: aws
runtime: nodejs14.x
functions:
hello:
handler: handler.hello

functions:
hello:
handler: handler.hello
events:
- http:
path: hello
method: get

functions:
hello:
handler: handler.hello
events:
- http:
path: hello
method: get
- schedule:
rate: rate(10 minutes)

resources:
Resources:
MyDynamoDBTable:
Type: AWS::DynamoDB::Table
Properties:
TableName: my-table
AttributeDefinitions:
- AttributeName: id
AttributeType: S
KeySchema:
- AttributeName: id
KeyType: HASH
ProvisionedThroughput:
ReadCapacityUnits: 1
WriteCapacityUnits: 1

yamlCopy codeprovider:
name: aws
runtime: nodejs14.x
region: us-east-1
stage: dev

provider:
stage: dev

provider:
region: us-west-2

plugins:
- serverless-offline
- serverless-webpack

layers:
commonLibs:
path: layer-common
functions:
hello:
handler: handler.hello
layers:
- { Ref: CommonLibsLambdaLayer }

functions:
hello:
handler: handler.hello
environment:
TABLE_NAME: ${self:custom.tableName}

custom:
tableName: my-dynamodb-table
stage: ${opt:stage, 'dev'}

¡outputs:
ApiEndpoint:
Description: "API Gateway endpoint URL"
Value:
Fn::Join:
- ""
- - "https://"
- Ref: ApiGatewayRestApi
- ".execute-api."
- Ref: AWS::Region
- ".amazonaws.com/"
- Ref: AWS::Stage

provider:
[...]
iam:
role:
statements:
- Effect: 'Allow'
Action:
- 'dynamodb:PutItem'
- 'dynamodb:Get*'
- 'dynamodb:Scan*'
- 'dynamodb:UpdateItem'
- 'dynamodb:DeleteItem'
Resource: arn:aws:dynamodb:${aws:region}:${aws:accountId}:table/${self:service}-customerTable-${sls:stage}

provider:
environment:
STAGE: ${self:provider.stage}
functions:
hello:
handler: handler.hello
environment:
TABLE_NAME: ${self:custom.tableName}

plugins:
- serverless-webpack

custom:
hooks:
before:deploy:deploy: echo "Starting deployment..."

Tutorial

Dies ist eine Zusammenfassung des offiziellen Tutorials aus den Dokumenten:

1. Erstellen Sie ein AWS-Konto (Serverless.com startet in der AWS-Infrastruktur)
2. Erstellen Sie ein Konto bei serverless.com
3. Erstellen Sie eine App:

# Create temp folder for the tutorial
mkdir /tmp/serverless-tutorial
cd /tmp/serverless-tutorial

# Install Serverless cli
npm install -g serverless

# Generate template
serverless #Choose first one (AWS / Node.js / HTTP API)
## Indicate a name like "Tutorial"
## Login/Register
## Create A New App
## Indicate a name like "tutorialapp)

Dies sollte eine App namens tutorialapp erstellt haben, die Sie in serverless.com überprüfen können, sowie einen Ordner namens Tutorial mit der Datei handler.js, die einige JS-Code mit einem helloworld-Code enthält, und der Datei serverless.yml, die diese Funktion deklariert:

exports.hello = async (event) => {
return {
statusCode: 200,
body: JSON.stringify({
message: "Go Serverless v4! Your function executed successfully!",
}),
}
}

# "org" ensures this Service is used with the correct Serverless Framework Access Key.
org: testing12342
# "app" enables Serverless Framework Dashboard features and sharing them with other Services.
app: tutorialapp
# "service" is the name of this project. This will also be added to your AWS resource names.
service: Tutorial

provider:
name: aws
runtime: nodejs20.x

functions:
hello:
handler: handler.hello
events:
- httpApi:
path: /
method: get

4. Erstellen Sie einen AWS-Anbieter, indem Sie im Dashboard zu https://app.serverless.com/<org name>/settings/providers?providerId=new&provider=aws gehen.
5. Um serverless.com Zugriff auf AWS zu gewähren, wird es aufgefordert, einen CloudFormation-Stack mit dieser Konfigurationsdatei auszuführen (zum Zeitpunkt des Schreibens): https://serverless-framework-template.s3.amazonaws.com/roleTemplate.yml
6. Diese Vorlage generiert eine Rolle mit dem Namen SFRole-<ID> mit arn:aws:iam::aws:policy/AdministratorAccess über das Konto mit einer Vertrauensidentität, die dem Serverless.com AWS-Konto den Zugriff auf die Rolle ermöglicht.

Description: This stack creates an IAM role that can be used by Serverless Framework for use in deployments.
Resources:
SFRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
AWS: arn:aws:iam::486128539022:root
Action:
- sts:AssumeRole
Condition:
StringEquals:
sts:ExternalId: !Sub "ServerlessFramework-${OrgUid}"
Path: /
RoleName: !Ref RoleName
ManagedPolicyArns:
- arn:aws:iam::aws:policy/AdministratorAccess
ReporterFunction:
Type: Custom::ServerlessFrameworkReporter
Properties:
ServiceToken: "arn:aws:lambda:us-east-1:486128539022:function:sp-providers-stack-reporter-custom-resource-prod-tmen2ec"
OrgUid: !Ref OrgUid
RoleArn: !GetAtt SFRole.Arn
Alias: !Ref Alias
Outputs:
SFRoleArn:
Description: "ARN for the IAM Role used by Serverless Framework"
Value: !GetAtt SFRole.Arn
Parameters:
OrgUid:
Description: Serverless Framework Org Uid
Type: String
Alias:
Description: Serverless Framework Provider Alias
Type: String
RoleName:
Description: Serverless Framework Role Name
Type: String

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::486128539022:root"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"sts:ExternalId": "ServerlessFramework-7bf7ddef-e1bf-43eb-a111-4d43e0894ccb"
}
}
}
]
}

5. Das Tutorial fordert dazu auf, die Datei createCustomer.js zu erstellen, die im Grunde einen neuen API-Endpunkt erstellt, der von der neuen JS-Datei verarbeitet wird, und fordert dazu auf, die Datei serverless.yml zu ändern, um eine neue DynamoDB-Tabelle zu generieren, eine Umgebungsvariable zu definieren und die Rolle, die die generierten Lambdas verwenden wird.

"use strict"
const AWS = require("aws-sdk")
module.exports.createCustomer = async (event) => {
const body = JSON.parse(Buffer.from(event.body, "base64").toString())
const dynamoDb = new AWS.DynamoDB.DocumentClient()
const putParams = {
TableName: process.env.DYNAMODB_CUSTOMER_TABLE,
Item: {
primary_key: body.name,
email: body.email,
},
}
await dynamoDb.put(putParams).promise()
return {
statusCode: 201,
}
}

# "org" ensures this Service is used with the correct Serverless Framework Access Key.
org: testing12342
# "app" enables Serverless Framework Dashboard features and sharing them with other Services.
app: tutorialapp
# "service" is the name of this project. This will also be added to your AWS resource names.
service: Tutorial

provider:
name: aws
runtime: nodejs20.x
environment:
DYNAMODB_CUSTOMER_TABLE: ${self:service}-customerTable-${sls:stage}
iam:
role:
statements:
- Effect: "Allow"
Action:
- "dynamodb:PutItem"
- "dynamodb:Get*"
- "dynamodb:Scan*"
- "dynamodb:UpdateItem"
- "dynamodb:DeleteItem"
Resource: arn:aws:dynamodb:${aws:region}:${aws:accountId}:table/${self:service}-customerTable-${sls:stage}

functions:
hello:
handler: handler.hello
events:
- httpApi:
path: /
method: get
createCustomer:
handler: createCustomer.createCustomer
events:
- httpApi:
path: /
method: post

resources:
Resources:
CustomerTable:
Type: AWS::DynamoDB::Table
Properties:
AttributeDefinitions:
- AttributeName: primary_key
AttributeType: S
BillingMode: PAY_PER_REQUEST
KeySchema:
- AttributeName: primary_key
KeyType: HASH
TableName: ${self:service}-customerTable-${sls:stage}

6. Bereitstellung mit serverless deploy
7. Die Bereitstellung erfolgt über einen CloudFormation Stack
8. Beachten Sie, dass die lambdas über API Gateway exponiert sind und nicht über direkte URLs
9. Testen Sie es
10. Der vorherige Schritt gibt die URLs aus, unter denen Ihre API-Endpunkt-Lambda-Funktionen bereitgestellt wurden

Sicherheitsüberprüfung von Serverless.com

Fehlkonfigurierte IAM-Rollen und Berechtigungen

Übermäßig permissive IAM-Rollen können unbefugten Zugriff auf Cloud-Ressourcen gewähren, was zu Datenverletzungen oder Ressourcenmanipulation führen kann.

Wenn keine Berechtigungen für eine Lambda-Funktion angegeben sind, wird eine Rolle mit Berechtigungen nur zum Generieren von Protokollen erstellt, wie:

{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"logs:CreateLogStream",
"logs:CreateLogGroup",
"logs:TagResource"
],
"Resource": [
"arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/jito-cranker-scripts-dev*:*"
],
"Effect": "Allow"
},
{
"Action": ["logs:PutLogEvents"],
"Resource": [
"arn:aws:logs:us-east-1:123456789012:log-group:/aws/lambda/jito-cranker-scripts-dev*:*:*"
],
"Effect": "Allow"
}
]
}

Minderungsstrategien

• Prinzip der geringsten Privilegien: Weisen Sie jeder Funktion nur die notwendigen Berechtigungen zu.

provider:
[...]
iam:
role:
statements:
- Effect: 'Allow'
Action:
- 'dynamodb:PutItem'
- 'dynamodb:Get*'
- 'dynamodb:Scan*'
- 'dynamodb:UpdateItem'
- 'dynamodb:DeleteItem'
Resource: arn:aws:dynamodb:${aws:region}:${aws:accountId}:table/${self:service}-customerTable-${sls:stage}

• Verwenden Sie separate Rollen: Unterscheiden Sie Rollen basierend auf den Anforderungen der Funktion.

Unsichere Geheimnisse und Konfigurationsmanagement

Das Speichern sensibler Informationen (z. B. API-Schlüssel, Datenbankanmeldeinformationen) direkt in serverless.yml oder Code kann zu einer Offenlegung führen, wenn Repositories kompromittiert werden.

Die empfohlene Methode zum Speichern von Umgebungsvariablen in der serverless.yml-Datei von serverless.com (zum Zeitpunkt dieses Schreibens) besteht darin, die ssm- oder s3-Provider zu verwenden, die es ermöglichen, die Umgebungswerte aus diesen Quellen zur Bereitstellungszeit abzurufen und die **Umgebungsvariablen der lambdas mit dem Text ohne die Werte zu konfigurieren!

Zum Beispiel wird das folgende Beispiel SSM verwenden, um eine Umgebungsvariable abzurufen:

provider:
environment:
DB_PASSWORD: ${ssm:/aws/reference/secretsmanager/my-db-password~true}

Und selbst wenn dies das Hardcoding des Wertes der Umgebungsvariable in der serverless.yml-Datei verhindert, wird der Wert zur Zeit der Bereitstellung abgerufen und wird im Klartext in der Lambda-Umgebungsvariable hinzugefügt.

Minderungsstrategien

• Secrets Manager Integration: Verwenden Sie Dienste wie AWS Secrets Manager.
• Verschlüsselte Variablen: Nutzen Sie die Verschlüsselungsfunktionen des Serverless Frameworks für sensible Daten.
• Zugriffskontrollen: Beschränken Sie den Zugriff auf Geheimnisse basierend auf Rollen.

Anfälliger Code und Abhängigkeiten

Veraltete oder unsichere Abhängigkeiten können Schwachstellen einführen, während unsachgemäße Eingabeverarbeitung zu Code-Injection-Angriffen führen kann.

Minderungsstrategien

• Abhängigkeitsmanagement: Aktualisieren Sie regelmäßig Abhängigkeiten und scannen Sie nach Schwachstellen.

plugins:
- serverless-webpack
- serverless-plugin-snyk

• Eingangsvalidierung: Implementieren Sie strenge Validierung und Sanitärung aller Eingaben.
• Code-Überprüfungen: Führen Sie gründliche Überprüfungen durch, um Sicherheitsfehler zu identifizieren.
• Statische Analyse: Verwenden Sie Tools, um Schwachstellen im Code zu erkennen.

Unzureichendes Logging und Monitoring

Ohne angemessenes Logging und Monitoring können böswillige Aktivitäten unentdeckt bleiben, was die Reaktion auf Vorfälle verzögert.

Minderungsstrategien

• Zentralisiertes Logging: Aggregieren Sie Protokolle mit Diensten wie AWS CloudWatch oder Datadog.

plugins:
- serverless-plugin-datadog

• Aktivieren Sie detailliertes Logging: Erfassen Sie wesentliche Informationen, ohne sensible Daten offenzulegen.
• Einrichten von Warnungen: Konfigurieren Sie Warnungen für verdächtige Aktivitäten oder Anomalien.
• Regelmäßige Überwachung: Überwachen Sie kontinuierlich Protokolle und Metriken auf potenzielle Sicherheitsvorfälle.

Unsichere API-Gateway-Konfigurationen

Offene oder unsachgemäß gesicherte APIs können für unbefugten Zugriff, Denial-of-Service (DoS)-Angriffe oder Cross-Site-Angriffe ausgenutzt werden.

Minderungsstrategien

• Authentifizierung und Autorisierung: Implementieren Sie robuste Mechanismen wie OAuth, API-Schlüssel oder JWT.

functions:
hello:
handler: handler.hello
events:
- http:
path: hello
method: get
authorizer: aws_iam

• Ratenbegrenzung und Drosselung: Verhindern Sie Missbrauch, indem Sie die Anforderungsraten begrenzen.

provider:
apiGateway:
throttle:
burstLimit: 200
rateLimit: 100

• Sichere CORS-Konfiguration: Beschränken Sie erlaubte Ursprünge, Methoden und Header.

functions:
hello:
handler: handler.hello
events:
- http:
path: hello
method: get
cors:
origin: https://yourdomain.com
headers:
- Content-Type

• Verwenden Sie Web Application Firewalls (WAF): Filtern und überwachen Sie HTTP-Anfragen auf bösartige Muster.

Unzureichende Funktionsisolierung

Geteilte Ressourcen und unzureichende Isolation können zu Privilegieneskalationen oder unbeabsichtigten Interaktionen zwischen Funktionen führen.

Minderungsstrategien

• Funktionen isolieren: Weisen Sie unterschiedliche Ressourcen und IAM-Rollen zu, um einen unabhängigen Betrieb sicherzustellen.
• Ressourcenteilung: Verwenden Sie separate Datenbanken oder Speicherorte für verschiedene Funktionen.
• Verwenden Sie VPCs: Stellen Sie Funktionen innerhalb von Virtual Private Clouds für verbesserte Netzisolierung bereit.

provider:
vpc:
securityGroupIds:
- sg-xxxxxxxx
subnetIds:
- subnet-xxxxxx

• Berechtigungen für Funktionen einschränken: Stellen Sie sicher, dass Funktionen nicht auf die Ressourcen anderer Funktionen zugreifen oder diese beeinträchtigen können, es sei denn, dies ist ausdrücklich erforderlich.

Unzureichender Datenschutz

Unverschlüsselte Daten im Ruhezustand oder während der Übertragung können offengelegt werden, was zu Datenverletzungen oder Manipulationen führen kann.

Minderungsstrategien

• Daten im Ruhezustand verschlüsseln: Nutzen Sie die Verschlüsselungsfunktionen des Cloud-Dienstes.

resources:
Resources:
MyDynamoDBTable:
Type: AWS::DynamoDB::Table
Properties:
SSESpecification:
SSEEnabled: true

• Daten während der Übertragung verschlüsseln: Verwenden Sie HTTPS/TLS für alle Datenübertragungen.
• Sichere API-Kommunikation: Erzwingen Sie Verschlüsselungsprotokolle und validieren Sie Zertifikate.
• Verwalten Sie Verschlüsselungsschlüssel sicher: Verwenden Sie verwaltete Schlüsseldienste und rotieren Sie Schlüssel regelmäßig.

Mangelnde ordnungsgemäße Fehlerbehandlung

Detaillierte Fehlermeldungen können sensible Informationen über die Infrastruktur oder den Code offenlegen, während nicht behandelte Ausnahmen zu Anwendungsabstürzen führen können.

Minderungsstrategien

• Allgemeine Fehlermeldungen: Vermeiden Sie die Offenlegung interner Details in Fehlermeldungen.

javascriptCopy code// Beispiel in Node.js
exports.hello = async (event) => {
try {
// Funktionslogik
} catch (error) {
console.error(error);
return {
statusCode: 500,
body: JSON.stringify({ message: 'Interner Serverfehler' }),
};
}
};

• Zentralisierte Fehlerbehandlung: Verwalten und sanitieren Sie Fehler konsistent über alle Funktionen hinweg.
• Überwachen und Protokollieren von Fehlern: Verfolgen und analysieren Sie Fehler intern, ohne Details für Endbenutzer offenzulegen.

Unsichere Bereitstellung Praktiken

Offengelegte Bereitstellungskonfigurationen oder unbefugter Zugriff auf CI/CD-Pipelines können zu böswilligen Codebereitstellungen oder Fehlkonfigurationen führen.

Minderungsstrategien

• Sichere CI/CD-Pipelines: Implementieren Sie strenge Zugriffskontrollen, Multi-Faktor-Authentifizierung (MFA) und regelmäßige Audits.
• Konfiguration sicher speichern: Halten Sie Bereitstellungsdateien frei von hardcodierten Geheimnissen und sensiblen Daten.
• Verwenden Sie Sicherheitswerkzeuge für Infrastruktur als Code (IaC): Verwenden Sie Tools wie Checkov oder Terraform Sentinel, um Sicherheitsrichtlinien durchzusetzen.
• Unveränderliche Bereitstellungen: Verhindern Sie unbefugte Änderungen nach der Bereitstellung, indem Sie Praktiken für unveränderliche Infrastruktur übernehmen.

Schwachstellen in Plugins und Erweiterungen

Die Verwendung von nicht geprüften oder bösartigen Drittanbieter-Plugins kann Schwachstellen in Ihren serverlosen Anwendungen einführen.

Minderungsstrategien

• Plugins gründlich prüfen: Bewerten Sie die Sicherheit von Plugins vor der Integration und bevorzugen Sie solche aus seriösen Quellen.
• Verwendung von Plugins einschränken: Verwenden Sie nur notwendige Plugins, um die Angriffsfläche zu minimieren.
• Überwachen Sie Plugin-Updates: Halten Sie Plugins auf dem neuesten Stand, um von Sicherheitsupdates zu profitieren.
• Isolieren Sie Plugin-Umgebungen: Führen Sie Plugins in isolierten Umgebungen aus, um potenzielle Kompromisse einzudämmen.

Offenlegung sensibler Endpunkte

Öffentlich zugängliche Funktionen oder uneingeschränkte APIs können für unbefugte Operationen ausgenutzt werden.

Minderungsstrategien

• Zugriff auf Funktionen einschränken: Verwenden Sie VPCs, Sicherheitsgruppen und Firewall-Regeln, um den Zugriff auf vertrauenswürdige Quellen zu beschränken.
• Robuste Authentifizierung implementieren: Stellen Sie sicher, dass alle exponierten Endpunkte eine ordnungsgemäße Authentifizierung und Autorisierung erfordern.
• API-Gateways sicher verwenden: Konfigurieren Sie API-Gateways, um Sicherheitsrichtlinien durchzusetzen, einschließlich Eingangsvalidierung und Ratenbegrenzung.
• Deaktivieren Sie ungenutzte Endpunkte: Überprüfen Sie regelmäßig und deaktivieren Sie alle Endpunkte, die nicht mehr verwendet werden.

Übermäßige Berechtigungen für Teammitglieder und externe Mitarbeiter

Das Gewähren übermäßiger Berechtigungen an Teammitglieder und externe Mitarbeiter kann zu unbefugtem Zugriff, Datenverletzungen und Missbrauch von Ressourcen führen. Dieses Risiko ist in Umgebungen erhöht, in denen mehrere Personen unterschiedliche Zugriffsrechte haben, was die Angriffsfläche und das Potenzial für Insider-Bedrohungen erhöht.

Minderungsstrategien

• Prinzip der geringsten Privilegien: Stellen Sie sicher, dass Teammitglieder und Mitarbeiter nur die Berechtigungen haben, die erforderlich sind, um ihre Aufgaben auszuführen.

Sicherheit von Zugriffsschlüsseln und Lizenzschlüsseln

Zugriffsschlüssel und Lizenzschlüssel sind kritische Anmeldeinformationen, die zur Authentifizierung und Autorisierung von Interaktionen mit der Serverless Framework CLI verwendet werden.

• Lizenzschlüssel: Sie sind eindeutige Identifikatoren, die für die Authentifizierung des Zugriffs auf die Serverless Framework Version 4 erforderlich sind, die eine Anmeldung über die CLI ermöglicht.
• Zugriffsschlüssel: Anmeldeinformationen, die es der Serverless Framework CLI ermöglichen, sich beim Serverless Framework Dashboard zu authentifizieren. Bei der Anmeldung mit serverless cli wird ein Zugriffsschlüssel generiert und auf dem Laptop gespeichert. Sie können ihn auch als Umgebungsvariable mit dem Namen SERVERLESS_ACCESS_KEY festlegen.

Sicherheitsrisiken

1. Offenlegung durch Code-Repositories:

• Hardcoding oder versehentliches Committen von Zugriffsschlüsseln und Lizenzschlüsseln in Versionskontrollsysteme kann zu unbefugtem Zugriff führen.

2. Unsichere Speicherung:

• Das Speichern von Schlüsseln im Klartext innerhalb von Umgebungsvariablen oder Konfigurationsdateien ohne angemessene Verschlüsselung erhöht die Wahrscheinlichkeit eines Lecks.

3. Unsachgemäße Verteilung:

• Das Teilen von Schlüsseln über unsichere Kanäle (z. B. E-Mail, Chat) kann zu einer Abfangung durch böswillige Akteure führen.

4. Mangelnde Rotation:

• Das regelmäßige Rotieren von Schlüsseln verlängert die Expositionszeit, wenn Schlüssel kompromittiert werden.

5. Übermäßige Berechtigungen:

• Schlüssel mit breiten Berechtigungen können ausgenutzt werden, um unbefugte Aktionen über mehrere Ressourcen hinweg durchzuführen.