# Serverless.com Sekuriteit

{{#include ../banners/hacktricks-training.md}}

## Basiese Inligting

### Organisasie

'n **Organisasie** is die hoogste vlak entiteit binne die Serverless Framework ekosisteem. Dit verteenwoordig 'n **kollektiewe groep**, soos 'n maatskappy, departement, of enige groot entiteit, wat verskeie projekte, spanne, en toepassings insluit.

### Span

Die **Span** is die gebruikers met toegang binne die organisasie. Spanne help om lede te organiseer op grond van rolle. **`Samewerkers`** kan bestaande toepassings sien en ontplooi, terwyl **`Admins`** nuwe toepassings kan skep en organisasie-instellings kan bestuur.

### Toepassing

'n **App** is 'n logiese groepe van verwante dienste binne 'n Organisasie. Dit verteenwoordig 'n volledige toepassing wat bestaan uit verskeie serverless dienste wat saamwerk om 'n samehangende funksionaliteit te bied.

### **Dienste**

'n **Diens** is die kernkomponent van 'n Serverless toepassing. Dit verteenwoordig jou hele serverless projek, wat al die funksies, konfigurasies, en hulpbronne insluit wat nodig is. Dit word tipies gedefinieer in 'n `serverless.yml` lêer, 'n diens sluit metadata in soos die diensnaam, verskaffer konfigurasies, funksies, gebeurtenisse, hulpbronne, plugins, en persoonlike veranderlikes.
```yaml
service: my-service
provider:
name: aws
runtime: nodejs14.x
functions:
hello:
handler: handler.hello
```
<details>

<summary>Funksie</summary>

'n **Funksie** verteenwoordig 'n enkele serverless funksie, soos 'n AWS Lambda funksie. Dit bevat die kode wat uitgevoer word in reaksie op gebeurtenisse.

Dit is gedefinieer onder die `functions` afdeling in `serverless.yml`, wat die handler, runtime, gebeurtenisse, omgewingsveranderlikes, en ander instellings spesifiseer.
```yaml
functions:
hello:
handler: handler.hello
events:
- http:
path: hello
method: get
```
</details>

<details>

<summary>Gebeurtenis</summary>

**Gebeurtenisse** is triggers wat jou serverless funksies aanroep. Hulle definieer hoe en wanneer 'n funksie uitgevoer moet word.

Gewone gebeurtenistipes sluit HTTP versoeke, geskeduleerde gebeurtenisse (cron jobs), databasis gebeurtenisse, lêer opgelaai, en meer in.
```yaml
functions:
hello:
handler: handler.hello
events:
- http:
path: hello
method: get
- schedule:
rate: rate(10 minutes)
```
</details>

<details>

<summary>Hulpbronne</summary>

**Hulpbronne** stel jou in staat om addisionele wolk hulpbronne te definieer waarop jou diens afhanklik is, soos databasisse, stoor emmers, of IAM rolle.

Hulle word gespesifiseer onder die `resources` afdeling, dikwels met behulp van CloudFormation sintaksis vir AWS.
```yaml
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
```
</details>

<details>

<summary>Verskaffer</summary>

Die **Verskaffer** objek spesifiseer die wolkdiensteverskaffer (bv. AWS, Azure, Google Cloud) en bevat konfigurasie-instellings wat relevant is vir daardie verskaffer.

Dit sluit besonderhede in soos die runtime, streek, fase, en akrediteer.
```yaml
yamlCopy codeprovider:
name: aws
runtime: nodejs14.x
region: us-east-1
stage: dev
```
</details>

<details>

<summary>Fase en Streek</summary>

Die fase verteenwoordig verskillende omgewings (bv. ontwikkeling, staging, produksie) waar jou diens ontplooi kan word. Dit stel omgewings-spesifieke konfigurasies en ontplooiings in staat.
```yaml
provider:
stage: dev
```
Die streek spesifiseer die geografiese streek waar jou hulpbronne ontplooi sal word. Dit is belangrik vir latensie, nakoming en beskikbaarheids oorwegings.
```yaml
provider:
region: us-west-2
```
</details>

<details>

<summary>Plugins</summary>

**Plugins** brei die funksionaliteit van die Serverless Framework uit deur nuwe kenmerke by te voeg of te integreer met ander gereedskap en dienste. Hulle word onder die `plugins` afdeling gedefinieer en geïnstalleer via npm.
```yaml
plugins:
- serverless-offline
- serverless-webpack
```
</details>

<details>

<summary>Lae</summary>

**Lae** stel jou in staat om gedeelde kode of afhanklikhede apart van jou funksies te pak en te bestuur. Dit bevorder herbruikbaarheid en verminder die grootte van ontplooiingspakkette. Hulle word onder die `layers` afdeling gedefinieer en deur funksies verwys.
```yaml
layers:
commonLibs:
path: layer-common
functions:
hello:
handler: handler.hello
layers:
- { Ref: CommonLibsLambdaLayer }
```
</details>

<details>

<summary>Veranderlikes en Aangepaste Veranderlikes</summary>

**Veranderlikes** stel dinamiese konfigurasie in staat deur die gebruik van plekhouers wat by ontplooiingstyd opgelos word.

- **Sintaksis:** `${variable}` sintaksis kan omgewingveranderlikes, lêerinhoud, of ander konfigurasieparameters verwys.

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

* **Aangepaste Veranderlikes:** Die `custom` afdeling word gebruik om gebruiker-spesifieke veranderlikes en konfigurasies te definieer wat hergebruik kan word regdeur die `serverless.yml`.

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

</details>

<details>

<summary>Uitsette</summary>

**Uitsette** definieer die waardes wat teruggegee word nadat 'n diens ontplooi is, soos hulpbron ARNs, eindpunte, of ander nuttige inligting. Hulle word onder die `outputs` afdeling gespesifiseer en word dikwels gebruik om inligting aan ander dienste bloot te stel of vir maklike toegang na ontplooiing.
```yaml
¡outputs:
ApiEndpoint:
Description: "API Gateway endpoint URL"
Value:
Fn::Join:
- ""
- - "https://"
- Ref: ApiGatewayRestApi
- ".execute-api."
- Ref: AWS::Region
- ".amazonaws.com/"
- Ref: AWS::Stage
```
</details>

<details>

<summary>IAM Rolle en Toestemmings</summary>

**IAM Rolle en Toestemmings** definieer die sekuriteitsakkredite en toegangregte vir jou funksies en ander hulpbronne. Hulle word bestuur onder die `provider` of individuele funksie-instellings om nodige toestemmings te spesifiseer.
```yaml
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}
```
</details>

<details>

<summary>Omgewing Veranderlikes</summary>

**Veranderlikes** stel jou in staat om konfigurasie-instellings en geheime inligting aan jou funksies oor te dra sonder om dit hard te kodifiseer. Hulle word gedefinieer onder die `environment` afdeling vir óf die verskaffer óf individuele funksies.
```yaml
provider:
environment:
STAGE: ${self:provider.stage}
functions:
hello:
handler: handler.hello
environment:
TABLE_NAME: ${self:custom.tableName}
```
</details>

<details>

<summary>Afhangklikhede</summary>

**Afhangklikhede** bestuur die eksterne biblioteke en modules wat jou funksies benodig. Hulle word tipies hanteer deur middel van pakketbestuurders soos npm of pip, en saamgevoeg met jou ontplooiingspakket met behulp van gereedskap of plugins soos `serverless-webpack`.
```yaml
plugins:
- serverless-webpack
```
</details>

<details>

<summary>Hooks</summary>

**Hooks** laat jou toe om pasgemaakte skripte of opdragte op spesifieke punte in die ontplooiing lewensiklus uit te voer. Hulle word gedefinieer met behulp van plugins of binne die `serverless.yml` om aksies voor of na ontplooiings uit te voer.
```yaml
custom:
hooks:
before:deploy:deploy: echo "Starting deployment..."
```
</details>

### Tutorial

Dit is 'n opsomming van die amptelike tutoriaal [**uit die dokumentasie**](https://www.serverless.com/framework/docs/tutorial):

1. Skep 'n AWS-rekening (Serverless.com begin in AWS-infrastruktuur)
2. Skep 'n rekening in serverless.com
3. Skep 'n app:
```bash
# 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)
```
Dit behoort 'n **app** genaamd `tutorialapp` te geskep het wat jy kan nagaan in [serverless.com](serverless.com-security.md) en 'n gids genaamd `Tutorial` met die lêer **`handler.js`** wat 'n bietjie JS-kode met 'n `helloworld` kode bevat en die lêer **`serverless.yml`** wat daardie funksie verklaar:

{{#tabs }}
{{#tab name="handler.js" }}
```javascript
exports.hello = async (event) => {
return {
statusCode: 200,
body: JSON.stringify({
message: "Go Serverless v4! Your function executed successfully!",
}),
}
}
```
{{#endtab }}
{{#tab name="serverless.yml" }}
```yaml
# "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
```
{{#endtab }}
{{#endtabs }}

4. Skep 'n AWS verskaffer deur in die **dashboard** te gaan op `https://app.serverless.com/<org name>/settings/providers?providerId=new&provider=aws`.
1. Om `serverless.com` toegang tot AWS te gee, sal dit vra om 'n cloudformation-stapel te loop met behulp van hierdie konfigurasie-lêer (op die tyd van hierdie skrywe): [https://serverless-framework-template.s3.amazonaws.com/roleTemplate.yml](https://serverless-framework-template.s3.amazonaws.com/roleTemplate.yml)
2. Hierdie sjabloon genereer 'n rol genaamd **`SFRole-<ID>`** met **`arn:aws:iam::aws:policy/AdministratorAccess`** oor die rekening met 'n Trust Identity wat `Serverless.com` AWS-rekening toelaat om toegang tot die rol te verkry.

<details>

<summary>Yaml roleTemplate</summary>
```yaml
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
```
</details>

<details>

<summary>Vertrouensverhouding</summary>
```json
{
"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"
}
}
}
]
}
```
</details>

5. Die tutoriaal vra om die lêer `createCustomer.js` te skep wat basies 'n nuwe API-eindpunt sal skep wat deur die nuwe JS-lêer hanteer word en vra om die `serverless.yml`-lêer te wysig om 'n **nuwe DynamoDB-tabel** te genereer, 'n **omgewing veranderlike** te definieer, die rol wat die gegenereerde lambdas sal gebruik.

{{#tabs }}
{{#tab name="createCustomer.js" }}
```javascript
"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,
}
}
```
{{#endtab }}

{{#tab name="serverless.yml" }}
```yaml
# "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}
```
{{#endtab }}
{{#endtabs }}

6. Ontplooi dit met **`serverless deploy`**
1. Die ontplooiing sal uitgevoer word via 'n CloudFormation Stack
2. Let daarop dat die **lambdas blootgestel word via API gateway** en nie via direkte URL's nie
7. **Toets dit**
1. Die vorige stap sal die **URL's** druk waar jou API eindpunte lambda funksies ontplooi is

## Sekuriteits Hersiening van Serverless.com

### **Verkeerd Geconfigureerde IAM Rolle en Toestemmings**

Oormatig permissiewe IAM rolle kan ongeoorloofde toegang tot wolkbronne verleen, wat lei tot datalekke of bronmanipulasie.

Wanneer geen toestemmings vir 'n Lambda funksie gespesifiseer word nie, sal 'n rol met toestemmings net om logs te genereer geskep word, soos: 

<details>

<summary>Minimum lambda toestemmings</summary>
```json
{
"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"
}
]
}
```
</details>

#### **Versagingsstrategieë**

- **Beginsel van Minste Bevoegdheid:** Ken slegs die nodige toestemmings aan elke funksie toe.

```yaml
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}
```

- **Gebruik Afsonderlike Rolle:** Verskaf rolle gebaseer op funksievereistes.

---

### **Onveilige Geheime en Konfigurasiebestuur**

Die stoor van sensitiewe inligting (bv. API sleutels, databasis akrediteer) direk in **`serverless.yml`** of kode kan lei tot blootstelling as repositories gecompromitteer word.

Die **aanbevole** manier om omgewing veranderlikes in **`serverless.yml`** lêer van serverless.com (ten tyde van hierdie skrywe) te stoor, is om die `ssm` of `s3` verskaffers te gebruik, wat toelaat om die **omgewing waardes van hierdie bronne tydens ontplooiing te verkry** en die **lambdas** omgewing veranderlikes met die **tekst sonder die waardes** te **konfigureer**!

> [!CAUTION]
> Daarom sal enigeen met toestemmings om die lambdas konfigurasie binne AWS te lees, in staat wees om **toegang te verkry tot al hierdie omgewing veranderlikes in duidelike teks!**

Byvoorbeeld, die volgende voorbeeld sal SSM gebruik om 'n omgewing veranderlike te verkry:
```yaml
provider:
environment:
DB_PASSWORD: ${ssm:/aws/reference/secretsmanager/my-db-password~true}
```
En selfs al voorkom dit dat die omgewing veranderlike waarde in die **`serverless.yml`** lêer hardgecodeer word, sal die waarde tydens ontplooiing verkry word en sal dit **in duidelike teks binne die lambda omgewing veranderlike bygevoeg word**.

> [!TIP]
> Die aanbevole manier om omgewing veranderlikes met serveless.com te stoor, is om dit **in 'n AWS geheim te stoor** en net die geheimnaam in die omgewing veranderlike te stoor en die **lambda kode moet dit versamel**.

#### **Versagtingsstrategieë**

- **Secrets Manager Integrasie:** Gebruik dienste soos **AWS Secrets Manager.**
- **Gekodeerde Veranderlikes:** Maak gebruik van die Serverless Framework se kodering funksies vir sensitiewe data.
- **Toegangsbeheer:** Beperk toegang tot geheime gebaseer op rolle.

---

### **Kwetsbare Kode en Afhanklikhede**

Verouderde of onveilige afhanklikhede kan kwesbaarhede inbring, terwyl onvanpaste invoerhantering kan lei tot kode-inspuitaanvalle.

#### **Versagtingsstrategieë**

- **Afhanklikheidsbestuur:** Werk afhanklikhede gereeld op en skandeer vir kwesbaarhede.

```yaml
plugins:
- serverless-webpack
- serverless-plugin-snyk
```

- **Invoer Validasie:** Implementeer streng validasie en sanitasie van alle invoere.
- **Kode Hersienings:** Voer deeglike hersienings uit om sekuriteitsfoute te identifiseer.
- **Statische Analise:** Gebruik gereedskap om kwesbaarhede in die kodebasis te ontdek.

---

### **Onvoldoende Logging en Monitering**

Sonder behoorlike logging en monitering kan kwaadwillige aktiwiteite onopgemerk bly, wat die insidentrespons vertraag.

#### **Versagtingsstrategieë**

- **Gekonsolideerde Logging:** Aggregereer logs met dienste soos **AWS CloudWatch** of **Datadog**.

```yaml
plugins:
- serverless-plugin-datadog
```

- **Aktiveer Gedetailleerde Logging:** Vang noodsaaklike inligting sonder om sensitiewe data bloot te stel.
- **Stel Waarskuwings In:** Konfigureer waarskuwings vir verdagte aktiwiteite of afwykings.
- **Gereelde Monitering:** Moniteer logs en metrieke voortdurend vir potensiële sekuriteitsinsidente.

---

### **Onveilige API Gateway Konfigurasies**

Oop of onvanpaste beveiligde API's kan uitgebuit word vir ongeoorloofde toegang, Denial of Service (DoS) aanvalle, of kruis-web aanvalle.

#### **Versagtingsstrategieë**

- **Outentisering en Magtiging:** Implementeer robuuste meganismes soos OAuth, API sleutels, of JWT.

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

- **Tariefbeperking en Throttling:** Voorkom misbruik deur versoektempo's te beperk.

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

- **Veilige CORS Konfigurasie:** Beperk toegelate oorspronge, metodes, en koppe.

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

- **Gebruik Webtoepassing Vuurmure (WAF):** Filtreer en monitor HTTP versoeke vir kwaadwillige patrone.

---

### **Onvoldoende Funksie Isolasie**

Gedeelde hulpbronne en onvoldoende isolasie kan lei tot voorregverhogings of onbedoelde interaksies tussen funksies.

#### **Versagtingsstrategieë**

- **Isolasie van Funksies:** Ken unieke hulpbronne en IAM rolle toe om onafhanklike werking te verseker.
- **Hulpbron Partitionering:** Gebruik aparte databasisse of stoor emmers vir verskillende funksies.
- **Gebruik VPC's:** Ontplooi funksies binne Virtuele Privaatskywe vir verbeterde netwerkisolasie.

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

- **Beperk Funksie Toestemmings:** Verseker dat funksies nie toegang het tot of mekaar se hulpbronne kan beïnvloed nie, tensy dit eksplisiet vereis word.

---

### **Onvoldoende Data Beskerming**

Ongeëkodeerde data in rus of in oordrag kan blootgestel word, wat kan lei tot datalekke of vervalsing.

#### **Versagtingsstrategieë**

- **Enkripteer Data in Rus:** Maak gebruik van wolkdienste se enkripteerfunksies.

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

- **Enkripteer Data in Oordrag:** Gebruik HTTPS/TLS vir alle datatransmissies.
- **Veilige API Kommunikasie:** Handhaaf enkripteerprotokolle en valideer sertifikate.
- **Bestuur Enkripteersleutels Veilig:** Gebruik bestuurde sleuteldienste en roteer sleutels gereeld.

---

### **Gebrek aan Behoorlike Fout Hantering**

Gedetailleerde foutboodskappe kan sensitiewe inligting oor die infrastruktuur of kodebasis blootstel, terwyl onbehandelde uitsonderings kan lei tot toepassingskrake.

#### **Versagtingsstrategieë**

- **Generiese Foutboodskappe:** Vermy die blootstelling van interne besonderhede in foutantwoorde.

```javascript
javascriptCopy code// Voorbeeld in Node.js
exports.hello = async (event) => {
try {
// Funksielogika
} catch (error) {
console.error(error);
return {
statusCode: 500,
body: JSON.stringify({ message: 'Interne Bediener Fout' }),
};
}
};
```

- **Gekonsolideerde Fout Hantering:** Bestuur en saniteer foute konsekwent oor alle funksies.
- **Monitor en Log Foute:** Volg en analiseer foute intern sonder om besonderhede aan eindgebruikers bloot te stel.

---

### **Onveilige Ontplooiing Praktyke**

Blootgestelde ontplooiingskonfigurasies of ongeoorloofde toegang tot CI/CD-pype kan lei tot kwaadwillige kode-ontplooiings of misconfigurasies.

#### **Versagtingsstrategieë**

- **Veilige CI/CD Pype:** Implementeer streng toegangsbeheer, multi-faktor outentisering (MFA), en gereelde ouditte.
- **Stoor Konfigurasie Veilig:** Hou ontplooiingslêers vry van hardgecodeerde geheime en sensitiewe data.
- **Gebruik Infrastruktuur as Kode (IaC) Sekuriteitsgereedskap:** Gebruik gereedskap soos **Checkov** of **Terraform Sentinel** om sekuriteitsbeleide af te dwing.
- **Onveranderlike Ontplooiings:** Voorkom ongeoorloofde veranderinge na ontplooiing deur onveranderlike infrastruktuurpraktyke aan te neem.

---

### **Kwetsbaarhede in Plugins en Uitbreidings**

Die gebruik van ongeëvalueerde of kwaadwillige derdeparty-plugins kan kwesbaarhede in jou serverless toepassings inbring.

#### **Versagtingsstrategieë**

- **Evalueer Plugins Deeglik:** Beoordeel die sekuriteit van plugins voordat dit geïntegreer word, en verkies dié van betroubare bronne.
- **Beperk Plugin Gebruik:** Gebruik slegs noodsaaklike plugins om die aanvaloppervlak te minimaliseer.
- **Monitor Plugin Opdaterings:** Hou plugins op datum om voordeel te trek uit sekuriteitsopdaterings.
- **Isolasie van Plugin Omgewings:** Voer plugins in geïsoleerde omgewings uit om potensiële kompromies te bevat.

---

### **Blootstelling van Sensitiewe Eindpunte**

Publiek toeganklike funksies of onbeperkte API's kan uitgebuit word vir ongeoorloofde operasies.

#### **Versagtingsstrategieë**

- **Beperk Funksie Toegang:** Gebruik VPC's, sekuriteitsgroepe, en vuurmuur reels om toegang tot vertroude bronne te beperk.
- **Implementeer Robuuste Outentisering:** Verseker dat alle blootgestelde eindpunte behoorlike outentisering en magtiging vereis.
- **Gebruik API Gateways Veilig:** Konfigureer API Gateways om sekuriteitsbeleide af te dwing, insluitend invoervalidasie en tariefbeperking.
- **Deaktiveer Ongebruikte Eindpunte:** Hersien en deaktiveer gereeld enige eindpunte wat nie meer in gebruik is nie.

---

### **Oorvloedige Toestemmings vir Spanlede en Eksterne Samewerkers**

Die toekenning van oorvloedige toestemmings aan spanlede en eksterne samewerkers kan lei tot ongeoorloofde toegang, datalekke, en misbruik van hulpbronne. Hierdie risiko is verhoog in omgewings waar verskeie individue verskillende vlakke van toegang het, wat die aanvaloppervlak en potensiaal vir binnenshuise bedreigings verhoog.

#### **Versagtingsstrategieë**

- **Beginsel van Minste Voorreg:** Verseker dat spanlede en samewerkers slegs die toestemmings het wat nodig is om hul take uit te voer.

---

### **Toegang Sleutels en Lisensie Sleutels Sekuriteit**

**Toegang Sleutels** en **Lisensie Sleutels** is kritieke akrediteer wat gebruik word om interaksies met die Serverless Framework CLI te outentiseer en te magtig.

- **Lisensie Sleutels:** Dit is unieke identifiseerders wat benodig word om toegang tot Serverless Framework weergawe 4 te outentiseer wat toelaat om via CLI aan te meld.
- **Toegang Sleutels:** Akrediteer wat toelaat dat die Serverless Framework CLI met die Serverless Framework Dashboard outentiseer. Wanneer jy aanmeld met `serverless` cli, sal 'n toegang sleutel **gegenereer en op die skootrekenaar gestoor word**. Jy kan dit ook as 'n omgewing veranderlike genaamd `SERVERLESS_ACCESS_KEY` stel.

#### **Sekuriteitsrisiko's**

1. **Blootstelling Deur Kode Depositories:**
- Hardcoding of per ongeluk die toekennings sleutels en lisensie sleutels aan die weergawebeheerstelsels kan lei tot ongeoorloofde toegang.
2. **Onveilige Stoor:**
- Die stoor van sleutels in duidelike teks binne omgewing veranderlikes of konfigurasielêers sonder behoorlike enkripteer verhoog die waarskynlikheid van lekkasie.
3. **Onvanpaste Verspreiding:**
- Die deel van sleutels deur onveilige kanale (bv. e-pos, klets) kan lei tot onderskepping deur kwaadwillige akteurs.
4. **Gebrek aan Rotasie:**
- Om sleutels nie gereeld te roteer nie, verleng die blootstellingstydperk as sleutels gecompromitteer word.
5. **Oorvloedige Toestemmings:**
- Sleutels met breë toestemmings kan uitgebuit word om ongeoorloofde aksies oor verskeie hulpbronne uit te voer.

{{#include ../banners/hacktricks-training.md}}
