# Serverless.com Security

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

## Osnovne informacije

### Organizacija

**Organizacija** je entitet najvišeg nivoa unutar Serverless Framework ekosistema. Predstavlja **kolektivnu grupu**, kao što su kompanija, odeljenje ili bilo koja velika entitet, koja obuhvata više projekata, timova i aplikacija.

### Tim

**Tim** su korisnici sa pristupom unutar organizacije. Timovi pomažu u organizovanju članova na osnovu uloga. **`Saradnici`** mogu da pregledaju i implementiraju postojeće aplikacije, dok **`Administratori`** mogu da kreiraju nove aplikacije i upravljaju postavkama organizacije.

### Aplikacija

**Aplikacija** je logičko grupisanje povezanih usluga unutar Organizacije. Predstavlja kompletnu aplikaciju sastavljenu od više serverless usluga koje rade zajedno kako bi pružile koherentnu funkcionalnost.

### **Usluge**

**Usluga** je osnovna komponenta serverless aplikacije. Predstavlja ceo vaš serverless projekat, obuhvatajući sve funkcije, konfiguracije i resurse koji su potrebni. Obično je definisana u `serverless.yml` datoteci, usluga uključuje metapodatke kao što su naziv usluge, konfiguracije provajdera, funkcije, događaje, resurse, dodatke i prilagođene varijable.
```yaml
service: my-service
provider:
name: aws
runtime: nodejs14.x
functions:
hello:
handler: handler.hello
```
<details>

<summary>Funkcija</summary>

**Funkcija** predstavlja jednu serverless funkciju, kao što je AWS Lambda funkcija. Sadrži kod koji se izvršava kao odgovor na događaje.

Definira se u odeljku `functions` u `serverless.yml`, navodeći handler, runtime, događaje, promenljive okruženja i druge postavke.
```yaml
functions:
hello:
handler: handler.hello
events:
- http:
path: hello
method: get
```
</details>

<details>

<summary>Dejstvo</summary>

**Dejstva** su okidači koji pozivaju vaše serverless funkcije. Oni definišu kako i kada funkcija treba da se izvrši.

Uobičajeni tipovi dejstava uključuju HTTP zahteve, zakazane događaje (cron poslovi), događaje iz baze podataka, otpremanje fajlova i još mnogo toga.
```yaml
functions:
hello:
handler: handler.hello
events:
- http:
path: hello
method: get
- schedule:
rate: rate(10 minutes)
```
</details>

<details>

<summary>Resursi</summary>

**Resursi** vam omogućavaju da definišete dodatne cloud resurse na kojima vaša usluga zavisi, kao što su baze podataka, skladišni bucket-i ili IAM uloge.

Oni se definišu u okviru `resources` sekcije, često koristeći CloudFormation sintaksu za 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>Provajder</summary>

Objekat **Provajder** specificira provajdera cloud usluga (npr., AWS, Azure, Google Cloud) i sadrži konfiguracione postavke relevantne za tog provajdera.

Uključuje detalje kao što su runtime, region, stage i kredencijali.
```yaml
yamlCopy codeprovider:
name: aws
runtime: nodejs14.x
region: us-east-1
stage: dev
```
</details>

<details>

<summary>Faza i Region</summary>

Faza predstavlja različite okruženja (npr. razvoj, testiranje, proizvodnja) gde vaša usluga može biti postavljena. Omogućava konfiguracije i postavke specifične za okruženje.
```yaml
provider:
stage: dev
```
Region definiše geografsku oblast u kojoj će vaši resursi biti postavljeni. To je važno za latenciju, usklađenost i dostupnost.
```yaml
provider:
region: us-west-2
```
</details>

<details>

<summary>Plugins</summary>

**Plugins** proširuju funkcionalnost Serverless Framework-a dodavanjem novih funkcija ili integracijom sa drugim alatima i uslugama. Definišu se u sekciji `plugins` i instaliraju putem npm-a.
```yaml
plugins:
- serverless-offline
- serverless-webpack
```
</details>

<details>

<summary> slojevi </summary>

** slojevi ** vam omogućavaju da pakujete i upravljate deljenim kodom ili zavisnostima odvojeno od vaših funkcija. To promoviše ponovnu upotrebu i smanjuje veličine paketa za implementaciju. Definišu se u odeljku `layers` i pozivaju ih funkcije.
```yaml
layers:
commonLibs:
path: layer-common
functions:
hello:
handler: handler.hello
layers:
- { Ref: CommonLibsLambdaLayer }
```
</details>

<details>

<summary>Promenljive i Prilagođene Promenljive</summary>

**Promenljive** omogućavaju dinamičku konfiguraciju omogućavajući korišćenje mesta za rezervaciju koja se rešavaju u vreme implementacije.

- **Sintaksa:** `${variable}` sintaksa može referencirati promenljive okruženja, sadržaj datoteka ili druge konfiguracione parametre.

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

* **Prilagođene Promenljive:** `custom` sekcija se koristi za definisanje korisnički specifičnih promenljivih i konfiguracija koje se mogu ponovo koristiti kroz `serverless.yml`.

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

</details>

<details>

<summary>Izlazi</summary>

**Izlazi** definišu vrednosti koje se vraćaju nakon što je usluga implementirana, kao što su ARNs resursa, krajnje tačke ili druge korisne informacije. Oni se specificiraju pod `outputs` sekcijom i često se koriste za izlaganje informacija drugim uslugama ili za lak pristup nakon implementacije.
```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 Uloge i Dozvole</summary>

**IAM Uloge i Dozvole** definišu bezbednosne akreditive i prava pristupa za vaše funkcije i druge resurse. Upravljaju se pod `provider` ili podešavanjima pojedinačnih funkcija kako bi se odredile potrebne dozvole.
```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>Promenljive okruženja</summary>

**Promenljive** vam omogućavaju da prosledite podešavanja konfiguracije i tajne vašim funkcijama bez hardkodiranja. Definisane su u `environment` sekciji za provajdera ili pojedinačne funkcije.
```yaml
provider:
environment:
STAGE: ${self:provider.stage}
functions:
hello:
handler: handler.hello
environment:
TABLE_NAME: ${self:custom.tableName}
```
</details>

<details>

<summary>Zavisnosti</summary>

**Zavisnosti** upravljaju spoljnim bibliotekama i modulima koje vaše funkcije zahtevaju. Obično se upravlja putem menadžera paketa kao što su npm ili pip, i paketu za implementaciju se dodaju koristeći alate ili dodatke kao što je `serverless-webpack`.
```yaml
plugins:
- serverless-webpack
```
</details>

<details>

<summary>Hooks</summary>

**Hooks** omogućavaju pokretanje prilagođenih skripti ili komandi u određenim tačkama u životnom ciklusu implementacije. Definišu se korišćenjem dodataka ili unutar `serverless.yml` da bi se izvršile radnje pre ili posle implementacija.
```yaml
custom:
hooks:
before:deploy:deploy: echo "Starting deployment..."
```
</details>

### Tutorial

Ovo je sažetak zvaničnog tutorijala [**iz dokumentacije**](https://www.serverless.com/framework/docs/tutorial):

1. Kreirajte AWS nalog (Serverless.com počinje u AWS infrastrukturi)
2. Kreirajte nalog na serverless.com
3. Kreirajte aplikaciju:
```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)
```
Ovo bi trebalo da kreira **aplikaciju** pod nazivom `tutorialapp` koju možete proveriti na [serverless.com](serverless.com-security.md) i folder pod nazivom `Tutorial` sa fajlom **`handler.js`** koji sadrži neki JS kod sa `helloworld` kodom i fajlom **`serverless.yml`** koji deklarira tu funkciju:

{{#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. Kreirajte AWS provajder, odlaskom na **dashboard** na `https://app.serverless.com/<org name>/settings/providers?providerId=new&provider=aws`.
1. Da bi se `serverless.com` omogućio pristup AWS-u, biće zatraženo da se pokrene cloudformation stack koristeći ovaj konfiguracioni fajl (u vreme pisanja ovog teksta): [https://serverless-framework-template.s3.amazonaws.com/roleTemplate.yml](https://serverless-framework-template.s3.amazonaws.com/roleTemplate.yml)
2. Ovaj šablon generiše ulogu pod nazivom **`SFRole-<ID>`** sa **`arn:aws:iam::aws:policy/AdministratorAccess`** nad nalogom sa Trust Identity koja omogućava `Serverless.com` AWS nalogu pristup toj ulozi.

<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>Odnos poverenja</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. Tutorijal traži da se kreira fajl `createCustomer.js` koji će u suštini kreirati novu API tačku koju obrađuje novi JS fajl i traži da se izmeni fajl `serverless.yml` kako bi se generisala **nova DynamoDB tabela**, definisala **promenljiva okruženja**, i uloga koja će koristiti generisane lambde.

{{#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. Implementirajte ga koristeći **`serverless deploy`**
1. Implementacija će biti izvršena putem CloudFormation Stack-a
2. Imajte na umu da su **lambde izložene putem API gateway-a** a ne putem direktnih URL-ova
7. **Testirajte ga**
1. Prethodni korak će ispisati **URL-ove** gde su vaši API endpoint lambda funkcije implementirane

## Bezbednosna provera Serverless.com

### **Pogrešno konfigurisane IAM uloge i dozvole**

Previše permisivne IAM uloge mogu omogućiti neovlašćen pristup cloud resursima, što može dovesti do curenja podataka ili manipulacije resursima.

Kada nisu specificirane dozvole za Lambda funkciju, biće kreirana uloga sa dozvolama samo za generisanje logova, kao što je:

<details>

<summary>Minimalne lambda dozvole</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>

#### **Strategije ublažavanja**

- **Princip minimalnih privilegija:** Dodelite samo neophodne dozvole svakoj funkciji.

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

- **Koristite odvojene uloge:** Diferencirajte uloge na osnovu zahteva funkcije.

---

### **Nepouzdane tajne i upravljanje konfiguracijom**

Skladištenje osetljivih informacija (npr., API ključeva, kredencijala za bazu podataka) direktno u **`serverless.yml`** ili kodu može dovesti do izlaganja ako su repozitorijumi kompromitovani.

**Preporučeni** način skladištenja promenljivih okruženja u **`serverless.yml`** datoteci sa serverless.com (u vreme pisanja ovog teksta) je korišćenje `ssm` ili `s3` provajdera, što omogućava dobijanje **vrednosti okruženja iz ovih izvora u vreme implementacije** i **konfiguriše** promenljive okruženja **lambdas** sa **tekstom bez vrednosti**!

> [!CAUTION]
> Stoga, svako ko ima dozvole za čitanje konfiguracije lambdas unutar AWS-a moći će da **pristupi svim ovim promenljivim okruženja u čistom tekstu!**

Na primer, sledeći primer će koristiti SSM za dobijanje promenljive okruženja:
```yaml
provider:
environment:
DB_PASSWORD: ${ssm:/aws/reference/secretsmanager/my-db-password~true}
```
I čak i ako ovo sprečava hardkodiranje vrednosti promenljive okruženja u **`serverless.yml`** datoteci, vrednost će biti dobijena u vreme implementacije i biće **dodata u čistom tekstu unutar lambda promenljive okruženja**.

> [!TIP]
> Preporučeni način čuvanja promenljivih okruženja koristeći serveless.com bio bi da **se čuva u AWS tajni** i samo se ime tajne čuva u promenljivoj okruženja, a **lambda kod bi to trebao prikupiti**.

#### **Strategije ublažavanja**

- **Integracija sa Secrets Manager:** Koristite usluge kao što je **AWS Secrets Manager.**
- **Enkriptovane promenljive:** Iskoristite funkcije enkripcije Serverless Framework-a za osetljive podatke.
- **Kontrola pristupa:** Ograničite pristup tajnama na osnovu uloga.

---

### **Ranljiv kod i zavisnosti**

Zastarale ili nesigurne zavisnosti mogu uvesti ranjivosti, dok nepravilno rukovanje ulazima može dovesti do napada injekcijom koda.

#### **Strategije ublažavanja**

- **Upravljanje zavisnostima:** Redovno ažurirajte zavisnosti i skenirajte za ranjivosti.

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

- **Validacija ulaza:** Implementirajte strogu validaciju i sanitizaciju svih ulaza.
- **Revizije koda:** Sprovodite temeljne revizije kako biste identifikovali sigurnosne propuste.
- **Statička analiza:** Koristite alate za otkrivanje ranjivosti u kodnoj bazi.

---

### **Neadekvatno logovanje i nadgledanje**

Bez pravilnog logovanja i nadgledanja, zlonamerne aktivnosti mogu ostati neprimećene, odlažući odgovor na incidente.

#### **Strategije ublažavanja**

- **Centralizovano logovanje:** Agregirajte logove koristeći usluge kao što su **AWS CloudWatch** ili **Datadog**.

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

- **Omogućite detaljno logovanje:** Zabeležite bitne informacije bez izlaganja osetljivih podataka.
- **Postavite upozorenja:** Konfigurišite upozorenja za sumnjive aktivnosti ili anomalije.
- **Redovno nadgledanje:** Kontinuirano nadgledajte logove i metrike za potencijalne sigurnosne incidente.

---

### **Nesigurne konfiguracije API Gateway-a**

Otvoreni ili nepravilno zaštićeni API-ji mogu se iskoristiti za neovlašćen pristup, napade uskraćivanja usluge (DoS) ili napade između sajtova.

#### **Strategije ublažavanja**

- **Autentifikacija i autorizacija:** Implementirajte robusne mehanizme kao što su OAuth, API ključevi ili JWT.

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

- **Ograničavanje brzine i throttling:** Sprečite zloupotrebu ograničavanjem brzine zahteva.

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

- **Sigurna CORS konfiguracija:** Ograničite dozvoljene izvore, metode i zaglavlja.

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

- **Koristite vatrozide za web aplikacije (WAF):** Filtrirajte i nadgledajte HTTP zahteve za zlonamernim obrascima.

---

### **Nedovoljna izolacija funkcija**

Deljeni resursi i nedovoljna izolacija mogu dovesti do eskalacije privilegija ili nenamernih interakcija između funkcija.

#### **Strategije ublažavanja**

- **Izolujte funkcije:** Dodelite različite resurse i IAM uloge kako biste osigurali nezavisno delovanje.
- **Partitioning resursa:** Koristite odvojene baze podataka ili skladišne kante za različite funkcije.
- **Koristite VPC:** Implementirajte funkcije unutar Virtuelnih Privatnih Oblaka za poboljšanu mrežnu izolaciju.

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

- **Ograničite dozvole funkcija:** Osigurajte da funkcije ne mogu pristupiti ili ometati resurse jedne druge osim ako to nije izričito zahtevano.

---

### **Nedovoljna zaštita podataka**

Nešifrovani podaci u mirovanju ili u tranzitu mogu biti izloženi, što može dovesti do curenja podataka ili manipulacije.

#### **Strategije ublažavanja**

- **Šifrujte podatke u mirovanju:** Iskoristite funkcije šifrovanja usluga u oblaku.

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

- **Šifrujte podatke u tranzitu:** Koristite HTTPS/TLS za sve prenose podataka.
- **Osigurajte API komunikaciju:** Sprovodite protokole šifrovanja i validirajte sertifikate.
- **Sigurno upravljajte šifrovanjem ključeva:** Koristite upravljane usluge ključeva i redovno rotirajte ključeve.

---

### **Nedostatak pravilnog rukovanja greškama**

Detaljne poruke o greškama mogu otkriti osetljive informacije o infrastrukturi ili kodnoj bazi, dok neobrađene izuzetke mogu dovesti do rušenja aplikacije.

#### **Strategije ublažavanja**

- **Generičke poruke o greškama:** Izbegavajte izlaganje internih detalja u odgovorima na greške.

```javascript
javascriptCopy code// Primer u Node.js
exports.hello = async (event) => {
try {
// Logika funkcije
} catch (error) {
console.error(error);
return {
statusCode: 500,
body: JSON.stringify({ message: 'Internal Server Error' }),
};
}
};
```

- **Centralizovano rukovanje greškama:** Upravite i sanitizujte greške dosledno kroz sve funkcije.
- **Nadgledajte i logujte greške:** Pratite i analizirajte greške interno bez izlaganja detalja krajnjim korisnicima.

---

### **Nesigurne prakse implementacije**

Izložene konfiguracije implementacije ili neovlašćen pristup CI/CD pipelinima mogu dovesti do zlonamernih implementacija koda ili pogrešnih konfiguracija.

#### **Strategije ublažavanja**

- **Sigurni CI/CD pipelini:** Implementirajte stroge kontrole pristupa, višefaktorsku autentifikaciju (MFA) i redovne revizije.
- **Sigurno čuvanje konfiguracije:** Držite datoteke za implementaciju bez hardkodiranih tajni i osetljivih podataka.
- **Koristite alate za sigurnost infrastrukture kao koda (IaC):** Koristite alate kao što su **Checkov** ili **Terraform Sentinel** za sprovođenje sigurnosnih politika.
- **Imutabilne implementacije:** Sprečite neovlašćene promene nakon implementacije usvajanjem praksi imutabilne infrastrukture.

---

### **Ranjivosti u dodacima i ekstenzijama**

Korišćenje neproverenih ili zlonamernih dodataka trećih strana može uvesti ranjivosti u vaše serverless aplikacije.

#### **Strategije ublažavanja**

- **Temeljno proverite dodatke:** Procijenite sigurnost dodataka pre integracije, favorizujući one iz uglednih izvora.
- **Ograničite korišćenje dodataka:** Koristite samo neophodne dodatke kako biste smanjili površinu napada.
- **Nadgledajte ažuriranja dodataka:** Držite dodatke ažuriranim kako biste imali koristi od sigurnosnih zakrpa.
- **Izolujte okruženja dodataka:** Pokrećite dodatke u izolovanim okruženjima kako biste ograničili potencijalne kompromitacije.

---

### **Izloženost osetljivih krajnjih tačaka**

Javno dostupne funkcije ili neograničeni API-ji mogu se iskoristiti za neovlašćene operacije.

#### **Strategije ublažavanja**

- **Ograničite pristup funkcijama:** Koristite VPC, sigurnosne grupe i pravila vatrozida kako biste ograničili pristup pouzdanim izvorima.
- **Implementirajte robusnu autentifikaciju:** Osigurajte da sve izložene krajnje tačke zahtevaju odgovarajuću autentifikaciju i autorizaciju.
- **Sigurno koristite API Gateway:** Konfigurišite API Gateway da sprovodi sigurnosne politike, uključujući validaciju ulaza i ograničavanje brzine.
- **Onemogućite neiskorišćene krajnje tačke:** Redovno pregledajte i onemogućite sve krajnje tačke koje više nisu u upotrebi.

---

### **Prekomerne dozvole za članove tima i spoljne saradnike**

Dodeljivanje prekomernih dozvola članovima tima i spoljnim saradnicima može dovesti do neovlašćenog pristupa, curenja podataka i zloupotrebe resursa. Ovaj rizik se povećava u okruženjima gde više pojedinaca ima različite nivoe pristupa, povećavajući površinu napada i potencijal za unutrašnje pretnje.

#### **Strategije ublažavanja**

- **Princip najmanjih privilegija:** Osigurajte da članovi tima i saradnici imaju samo one dozvole koje su neophodne za obavljanje svojih zadataka.

---

### **Bezbednost pristupnih ključeva i licenci**

**Pristupni ključevi** i **ključevi licenci** su kritične akreditive koji se koriste za autentifikaciju i autorizaciju interakcija sa Serverless Framework CLI.

- **Ključevi licenci:** Oni su jedinstveni identifikatori potrebni za autentifikaciju pristupa Serverless Framework verziji 4 koja omogućava prijavu putem CLI.
- **Pristupni ključevi:** Akreditive koje omogućavaju Serverless Framework CLI da se autentifikuje sa Serverless Framework Dashboard-om. Kada se prijavite sa `serverless` cli, pristupni ključ će biti **generisan i sačuvan na laptopu**. Takođe ga možete postaviti kao promenljivu okruženja pod imenom `SERVERLESS_ACCESS_KEY`.

#### **Sigurnosni rizici**

1. **Izloženost kroz repozitorijume koda:**
- Hardkodiranje ili slučajno komitovanje pristupnih ključeva i ključeva licenci u sisteme za kontrolu verzija može dovesti do neovlašćenog pristupa.
2. **Nesigurno čuvanje:**
- Čuvanje ključeva u čistom tekstu unutar promenljivih okruženja ili konfiguracionih datoteka bez odgovarajuće enkripcije povećava verovatnoću curenja.
3. **Nepravilna distribucija:**
- Deljenje ključeva putem nesigurnih kanala (npr. e-pošta, chat) može rezultirati presretanjem od strane zlonamernih aktera.
4. **Nedostatak rotacije:**
- Ne redovno rotiranje ključeva produžava period izloženosti ako su ključevi kompromitovani.
5. **Prekomerne dozvole:**
- Ključevi sa širokim dozvolama mogu se iskoristiti za obavljanje neovlašćenih radnji na više resursa.

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