Modul 11 Web Security

Modul 11 - Web Security
Ikhtisar Kursus.........................................................................................................................4
Mekanisme Pembelajaran............................................................................................................. 4
Materi Teks Interaktif............................................................................................................... 4
Kuis Interaktif dan Latihan.......................................................................................................4
Proyek dan Tugas Praktis........................................................................................................ 5
Platform Diskusi............................................................................................................................. 5
Tipe-Tipe Resiko Keamanan pada Aplikasi Back-End............................................................... 5
SQL Injection...................................................................................................................................5
Authentication and Authorization Issues..................................................................................... 6
Data Security...................................................................................................................................8
Cross-Origin Resource Sharing (CORS)...................................................................................... 10
Cross-Site Request Forgery (CSRF)............................................................................................ 11
Security Misconfigurations..........................................................................................................13
Denial of Service (DoS) and Distributed Denial of Service (DDoS)........................................... 15
HTTPS vs HTTP..................................................................................................................... 17
Statelessness dan Implikasi HTTP............................................................................................. 17
Faedah Kepentingan Komunikasi dengan HTTPS..................................................................... 19
Man-in-the-Middle attacks........................................................................................................... 20
Eavesdropping dan Data Interception.........................................................................................22
Keunggulan HTTPS dan Manfaat HTTP/2................................................................................. 23
Cross-Origin Resource Sharing (CORS).................................................................................. 26
Memahami Cross-Origin Resource Sharing (CORS).................................................................. 26
Troubleshooting CORS Issues.....................................................................................................26
CORS Headers.............................................................................................................................. 27
Same-Origin Policy....................................................................................................................... 28
Simple Requests.......................................................................................................................... 30
Preflight Requests........................................................................................................................31
Implementasi API Security CORS dengan Echo......................................................................... 33
Handling CORS pada RESTful APIs.............................................................................................34
Cross-Site Request Forgery (CSRF) Prevention...................................................................... 36
Memahami Cross-Site Request Forgery (CSRF) Prevention..................................................... 36
Synchronizer Token Pattern (STP).............................................................................................. 37
Generate Token...................................................................................................................... 37
Validasi Token........................................................................................................................ 38
SameSite Cookies attribute......................................................................................................... 39
Double Submit Cookies approach...............................................................................................40
Membuat Token dan Menetapkannya ke Cookie.................................................................40
Anti-CSRF tokens in form submissions...................................................................................... 42
CsrfToken Struct.................................................................................................................... 42
GenerateToken Function....................................................................................................... 43
ValidateToken Function......................................................................................................... 43
showForm Handler................................................................................................................ 43
submitForm Handler..............................................................................................................44
Main Function.........................................................................................................................44
Mengidentifikasi dan Menanggulangi CSRF Vulnerabilities......................................................45
Struct MyForm........................................................................................................................46
Middleware addCSRFToken.................................................................................................. 46
Middleware checkCSRFToken...............................................................................................47
Fungsi generateCSRFToken.................................................................................................. 47
Handler handleForm.............................................................................................................. 48
Inisialisasi Echo dan Middleware..........................................................................................48
OWASP Security Risks........................................................................................................... 49
Memahami Web Security dan OWASP....................................................................................... 49
OWASP Application Security Verification Standard................................................................... 49
Input Validation............................................................................................................................ 50
Data Sanitization.......................................................................................................................... 52
Handling Sessions and Cookies..................................................................................................54
Secure File Handling and Uploading........................................................................................... 56
main Function.........................................................................................................................56
handleFileUpload Function....................................................................................................57
isValidFileType Function........................................................................................................58
saveFile Function................................................................................................................... 58
generateUniqueFileName Function...................................................................................... 59
SSL/TLS.................................................................................................................................59
Memahami SSL/TLS.................................................................................................................... 60
Persiapan SSL/TLS dengan crypto/tls........................................................................................60
Middleware untuk SSL/TLS......................................................................................................... 62
Secure Headers............................................................................................................................ 64
Handling Authentication.............................................................................................................. 66
Managing SSL/TLS Certificates.................................................................................................. 69
HTTP Strict Transport Security (HSTS)...................................................................................... 71
Testing dan Debugging................................................................................................................ 72
bcrypt.................................................................................................................................... 74
Memahami bcrypt........................................................................................................................ 74
Mengintegrasi bcrypt dengan User Authentication................................................................... 75
Salting untuk Additional Security................................................................................................ 77
Penjelasan Konsep................................................................................................................ 77
Implementasi dengan Golang dan Echo...............................................................................78
Contoh Kode...........................................................................................................................78
Password Policy dan Best Practices.......................................................................................... 79
main Function.........................................................................................................................79
registerUser Function............................................................................................................ 80
isStrongPassword Function.................................................................................................. 81
containsUppercase, containsLowercase, dan containsDigit Functions.............................82
Ikhtisar Kursus
Duration: 10:00
Last Updated: 2023-09-13
Mekanisme Pembelajaran
Hai Teman-teman SMKDEV, Selamat Datang 🙌🙌🙌 . Ini beberapa mekanisme yang kami
terapkan selama kamu mengakses pembelajaran ini agar menjadi tempat yang efektif untuk
meningkatkan efektifitas pembelajaran kamu.
Materi Teks Interaktif

Penyajian materi dalam bentuk teks yang mudah dipahami dan dilengkapi dengan elemen
interaktif seperti pecahan kode, penjelasan grafis, dan banyak lagi. Ini membantu kamu agar
dapat mudah diaplikasikan dalam proses pembelajaran kamu.
Kuis Interaktif dan Latihan

Menyediakan kuis interaktif atau latihan mandiri yang membantu kamu menguji pemahaman
mereka dan memperkuat konsep yang telah dipelajari. Materi yang akan digunakan sesuai yang
kamu pelajari sebelumnya. Walaupun kamu belum berhasil menjawab pertanyaan yang
diberikan, kamu dapat mengulang sehingga mendapatkan hasil yang terbaik
Proyek dan Tugas Praktis

Ini adalah step akhir yang perlu kamu selesaikan agar bisa menyelesaikan kursus/learning path
yang telah diberikan. Disini akan menyajikan tugas praktis atau proyek yang memungkinkan
kamu mengimplementasikan konsep yang telah kamu pelajari yang sesuai dengan
permasalahan yang diberikan sebagai panduan kamu dalam mengerjakan proyek tersebut.
Platform Diskusi
Selama kamu belajar pada platform ini, akan sangat memungkinkan adanya pertanyaan yang
dapat membantu menyelesaikan pembelajaran kamu. Disini juga memungkinkan kamu untuk
berinteraksi melalui forum atau fasilitas diskusi untuk berbagi pemikiran, memecahkan
masalah, dan belajar bersama. Para Curriculum Developer yang membangun kelas ini akan siap
membantu kamu jika ada pertanyaan yang berkaitan dengan proses pembelajaran kamu.
Untuk melakukan diskusi maupun pertanyaan yang berkaitan, kamu bisa bergabung ke
Komunitas SMKDEV disini
Tipe-Tipe Resiko Keamanan pada Aplikasi Back-End

Duration: 60:00
SQL Injection
SQL Injection adalah serangan keamanan pada aplikasi back-end yang memanfaatkan celah
keamanan dalam pengolahan input SQL. Serangan ini terjadi ketika input yang tidak dipercayai
oleh aplikasi diizinkan masuk ke pernyataan SQL tanpa validasi atau penyaringan yang
memadai. Tipe-tipe risiko keamanan yang dapat timbul akibat SQL Injection mencakup:
1. Pencurian Data Rahasia: SQL Injection dapat memungkinkan penyerang untuk
mengakses, mengubah, atau menghapus data sensitif dari basis data. Misalnya, seorang
penyerang dapat menggunakan pernyataan SQL yang dimodifikasi untuk mendapatkan
informasi pengguna atau data keuangan yang bersifat rahasia.
2. Manipulasi Data: Serangan ini memungkinkan penyerang untuk memanipulasi data
dalam basis data. Contohnya, seorang penyerang dapat menggunakan SQL Injection
untuk mengubah nilai-nilai tertentu dalam basis data, mengakibatkan perubahan yang
tidak sah atau merusak integritas data.
3. Eksekusi Perintah Sistem: Sebagai serangan tingkat lanjut, SQL Injection dapat
memungkinkan penyerang untuk menjalankan perintah sistem di server basis data. Ini
dapat membuka pintu bagi serangan yang lebih luas atau pemantauan server yang tidak
sah.
4. Penolakan Layanan (Denial of Service - DoS): Serangan SQL Injection yang berat dapat
menyebabkan beban server yang tinggi atau bahkan kegagalan sistem, mengakibatkan
penolakan layanan terhadap pengguna yang sah.
Misalkan ada suatu aplikasi web yang mengambil parameter dari URL untuk mengakses data
pengguna. Berikut adalah contoh kode PHP yang rentan terhadap SQL Injection:
<?php
// Mendapatkan nilai parameter dari URL
$user_id = $_GET['user_id'];
// Membuat pernyataan SQL tanpa validasi atau penyaringan

$sql = "SELECT * FROM users WHERE user_id = $user_id";
// Menjalankan pernyataan SQL
$result = mysqli_query($conn, $sql);
// Mengambil data dari hasil query

$row = mysqli_fetch_assoc($result);
// Menampilkan informasi pengguna

echo "Username: " . $row['username'] . "<br>";
echo "Email: " . $row['email'];
?>
Pada contoh di atas, nilai parameter user_id langsung dimasukkan ke dalam pernyataan SQL
tanpa verifikasi atau penyaringan. Seorang penyerang dapat memanipulasi nilai user_id
dengan menyertakan input yang merusak, seperti 1 OR 1=1, sehingga pernyataan SQL menjadi
SELECT * FROM users WHERE user_id = 1 OR 1=1, yang akan mengambil semua
data pengguna dari tabel, mengabaikan kondisi asli. Oleh karena itu, sangat penting untuk selalu
memvalidasi dan menyaring input pengguna untuk mencegah SQL Injection.
Authentication and Authorization Issues

Authentication dan authorization adalah dua aspek kunci dalam mengelola keamanan aplikasi
back-end menggunakan Golang. Authentication berkaitan dengan proses verifikasi identitas
pengguna, sementara authorization berkaitan dengan memberikan akses dan hak istimewa
berdasarkan identitas yang telah terverifikasi. Dalam konteks keamanan aplikasi back-end
Golang, terdapat beberapa tipe resiko keamanan yang berkaitan dengan authentication dan
authorization.
Salah satu masalah umum adalah kelemahan dalam implementasi authentication, di mana
sistem tidak dapat memastikan identitas pengguna dengan benar. Contoh kode sederhana
untuk proses authentication pada Golang dapat dilihat sebagai berikut:
// Contoh fungsi authentication sederhana

func authenticate(username, password string) bool {
// Logika autentikasi, misalnya, dengan membandingkan dengan
data yang ada di database
// Jika cocok, kembalikan true, jika tidak, kembalikan false
// Perhatikan bahwa ini hanya contoh sederhana dan seharusnya
tidak digunakan di lingkungan produksi
// Penggunaan library seperti bcrypt sangat disarankan untuk
keamanan yang lebih baik
// dan untuk menghindari resiko injection atau serangan
brute-force.
return (username == "pengguna" && password == "password")
}
Pada sisi authorization, masalah dapat timbul jika kontrol akses tidak diimplementasikan
dengan benar. Contoh sederhana implementasi authorization pada Golang bisa seperti berikut:
// Contoh middleware authorization sederhana

func authorize(next http.HandlerFunc, roles []string)
http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// Logika untuk memeriksa apakah pengguna memiliki hak
akses yang sesuai
// Misalnya, dapat diperiksa dari sesi atau token JWT
// Jika pengguna memiliki hak akses yang sesuai, panggil
handler berikutnya
// Jika tidak, kembalikan respons dengan status
Unauthorized
// dan beri pesan yang sesuai kepada pengguna
if userHasRoles(r, roles) {
next(w, r)
} else {
http.Error(w, "Unauthorized", http.StatusUnauthorized)
}
}
}
// Fungsi bantu untuk memeriksa hak akses pengguna

func userHasRoles(r *http.Request, roles []string) bool {
// Logika untuk memeriksa hak akses pengguna, misalnya, dari
token JWT
// Kembalikan true jika pengguna memiliki hak akses yang
sesuai, jika tidak, kembalikan false
// Ini hanya contoh sederhana dan metode validasi sesuai
kebutuhan aplikasi.
return true
}
Penting untuk diingat bahwa kedua contoh di atas hanya bersifat ilustratif dan tidak sesuai
untuk digunakan secara langsung di lingkungan produksi. Implementasi autentikasi dan
otorisasi yang kuat memerlukan pemahaman mendalam tentang keamanan informasi, dan
sebaiknya mengandalkan library dan metode yang telah teruji untuk menghindari resiko
keamanan yang tidak diinginkan.
Data Security
Data security pada aplikasi back-end yang menggunakan bahasa pemrograman Golang sangat
penting untuk mencegah berbagai tipe resiko keamanan. Salah satu aspek utama dalam data
security adalah enkripsi data. Dalam konteks Golang, menggunakan library bawaan seperti
crypto/rand dan crypto/aes untuk mengimplementasikan enkripsi data dapat menjadi langkah
awal yang baik. Enkripsi dapat digunakan untuk melindungi data sensitif seperti password,
token, dan informasi lainnya dari serangan pihak ketiga yang mencoba mengakses atau
memodifikasi data tersebut.
Selain itu, penggunaan HTTPS (Hypertext Transfer Protocol Secure) juga krusial untuk
melindungi data yang dikirimkan antara klien dan server. Golang menyediakan package
"net/http" yang memungkinkan implementasi server dengan dukungan HTTPS. Berikut adalah
contoh sederhana penggunaan HTTPS pada aplikasi back-end Golang:
package main
import (
"fmt"
"net/http"
)
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r
*http.Request) {
fmt.Fprintf(w, "Hello, this is a secure Golang
back-end!")
})
// Ganti "cert.pem" dan "key.pem" dengan sertifikat dan kunci

kita
err := http.ListenAndServeTLS(":8080", "cert.pem", "key.pem",
nil)
if err != nil {
fmt.Println("Error starting server:", err)
}
}
Dalam kode di atas, server Golang akan berjalan pada port 8080 dengan menggunakan HTTPS.
Pastikan untuk mengganti "cert.pem" dan "key.pem" dengan sertifikat dan kunci yang valid.
Selain itu, penanganan input dari pengguna adalah aspek penting lainnya untuk mencegah
resiko keamanan seperti SQL injection dan Cross-Site Scripting (XSS). Menggunakan
parameterized queries pada operasi database dan melakukan validasi input dapat membantu
melindungi aplikasi dari serangan jenis ini. Berikut adalah contoh sederhana penggunaan
parameterized query dengan database SQLite pada Golang:
package main
import (
"database/sql"
"fmt"
_ "github.com/mattn/go-sqlite3"
)
func main() {
db, err := sql.Open("sqlite3", "example.db")
if err != nil {
fmt.Println("Error opening database:", err)
return
}
defer db.Close()
// Contoh penggunaan parameterized query

username := "john_doe"
password := "secure_password"
_, err = db.Exec("INSERT INTO users (username, password)

VALUES (?, ?)", username, password)
if err != nil {
fmt.Println("Error executing query:", err)
return
}
fmt.Println("User added successfully.")

}
Dalam contoh di atas, parameterized query digunakan untuk memasukkan data ke dalam
database SQLite, mengurangi risiko SQL injection. Penting untuk selalu melakukan validasi input
dan menghindari langsung memasukkan nilai dari pengguna ke dalam query SQL.
Cross-Origin Resource Sharing (CORS)

Cross-Origin Resource Sharing (CORS) adalah sebuah mekanisme keamanan yang diterapkan
oleh browser web untuk memastikan bahwa permintaan sumber daya (seperti gambar, skrip,
atau data API) hanya dapat dilakukan oleh domain yang sama dengan domain sumber daya
tersebut. Pada aplikasi back-end Golang dan Echo, masalah keamanan CORS dapat muncul
ketika aplikasi di-host di domain tertentu, sedangkan permintaan datang dari domain yang
berbeda.
Tipe-tipe risiko keamanan pada aplikasi back-end Golang dan Echo yang terkait dengan CORS
melibatkan potensi ancaman seperti serangan CSRF (Cross-Site Request Forgery) atau akses
tidak sah ke sumber daya di server. Jika CORS tidak diatur dengan benar, permintaan lintas
domain dapat memberikan peluang bagi penyerang untuk mengeksploitasi kelemahan
keamanan. Untuk mengatasi risiko tersebut, kita perlu mengonfigurasi server Golang dan Echo
agar mendukung CORS dengan benar. Berikut adalah contoh kode sederhana untuk menangani
CORS pada aplikasi back-end Golang dan Echo:
package main
import (
"net/http"
"github.com/labstack/echo"
"github.com/labstack/echo/middleware"
)
func main() {
e := echo.New()
// Middleware untuk menangani CORS

e.Use(middleware.CORS())
// Rute contoh
e.GET("/data", func(c echo.Context) error {
return c.String(http.StatusOK, "Ini adalah data dari
server.")
})
e.Start(":8080")
}
Pada contoh di atas, middleware.CORS() digunakan untuk mengaktifkan dukungan CORS di
Echo. Middleware ini secara otomatis menangani header CORS seperti
Access-Control-Allow-Origin dan metode CORS lainnya. kita dapat menyesuaikan
konfigurasi CORS sesuai dengan kebutuhan aplikasi kita, seperti membatasi domain yang
diizinkan atau menanggapi dengan header kustom.
Dengan menambahkan dukungan CORS yang tepat pada aplikasi back-end Golang dan Echo,
kita dapat meminimalkan risiko keamanan terkait CORS dan menjaga aplikasi tetap aman dari
ancaman lintas domain yang tidak diinginkan.
Cross-Site Request Forgery (CSRF)

Cross-Site Request Forgery (CSRF) adalah serangan keamanan pada aplikasi web di mana
penyerang memanipulasi tindakan yang diambil oleh pengguna yang terotentikasi tanpa
pengetahuan atau persetujuannya. Pada aplikasi back-end yang dibangun dengan Golang dan
Echo, tipe-tipe resiko keamanan CSRF dapat merugikan pengguna dengan meretas otentikasi
mereka dan mengeksekusi tindakan yang tidak diinginkan.
Salah satu tipe resiko CSRF yang umum adalah serangan terhadap proses log out. Misalnya,
penyerang dapat membuat halaman web palsu yang mengandung permintaan HTTP untuk
melakukan log out dari akun pengguna tanpa persetujuannya. Jika pengguna yang terotentikasi
mengakses halaman ini tanpa menyadarinya, sesi mereka dapat diakhiri secara paksa,
memberikan akses penuh kepada penyerang.
Contoh sederhana implementasi CSRF pada aplikasi back-end Golang dan Echo dapat
diilustrasikan dengan menggunakan middleware. Berikut adalah contoh kode sederhana yang
memperlihatkan cara melindungi formulir dengan token CSRF:
package main
import (
"fmt"
"html/template"
"net/http"
"github.com/labstack/echo/v4"
"github.com/labstack/echo/v4/middleware"
)
var (
tmpl = template.Must(template.New("index").Parse(`
<!DOCTYPE html>
<html>
<head>
<title>CSRF Protection</title>
</head>
<body>
<form action="/process" method="post">
<input type="text" name="data" placeholder="Enter
data" required>
<input type="hidden" name="csrf" value="{{.}}">
<button type="submit">Submit</button>
</form>
</body>
</html>`))
)
func main() {
e := echo.New()
// Middleware for CSRF protection

e.Use(middleware.CSRFWithConfig(middleware.CSRFConfig{
TokenLength: 32,
TokenLookup: "form:csrf",
ContextKey: "csrf",
ErrorHandler: func(err error, c echo.Context) {
c.String(http.StatusBadRequest, "CSRF token
mismatch")
},
}))
// Routes
e.GET("/", func(c echo.Context) error {
token := c.Get("csrf").(string)
return tmpl.Execute(c.Response().Writer, token)
})
e.POST("/process", func(c echo.Context) error {

// Process the form submission
data := c.FormValue("data")
return c.String(http.StatusOK, fmt.Sprintf("Data
received: %s", data))
})
// Start the server

e.Start(":8080")
}
Pada contoh kode di atas, middleware CSRF dari Echo digunakan untuk menghasilkan dan
memeriksa token CSRF pada setiap permintaan POST. Token CSRF ditempatkan dalam formulir
HTML sebagai input tersembunyi, dan kemudian diperiksa oleh middleware pada setiap
permintaan POST. Jika token tidak sesuai, middleware akan menolak permintaan dengan
memberikan tanggapan kesalahan.
Security Misconfigurations
Security misconfigurations adalah salah satu jenis ancaman keamanan yang dapat mengintai
aplikasi back-end yang dikembangkan menggunakan bahasa pemrograman Golang dan
framework Echo. Misconfigurations terjadi ketika pengaturan sistem atau konfigurasi aplikasi
tidak tepat, meninggalkan celah yang dapat dimanfaatkan oleh penyerang untuk mengakses
informasi sensitif atau merusak integritas sistem.
Pada aplikasi back-end Golang dan Echo, security misconfigurations dapat muncul dalam
berbagai bentuk. Salah satu contoh umumnya adalah pengaturan izin dan autentikasi yang tidak
memadai. Jika aplikasi tidak memvalidasi dengan benar identitas dan hak akses pengguna,
penyerang dapat memanfaatkan kelemahan ini untuk mendapatkan akses yang tidak sah.
Contoh kode sederhana untuk mengilustrasikan security misconfigurations dapat terkait dengan
pengaturan koneksi ke database. Misalkan, aplikasi Golang menggunakan Echo framework dan
memiliki konfigurasi koneksi database sebagai berikut:
package main
import (
"database/sql"
"fmt"
"log"
"net/http"
)
func main() {
e := echo.New()
// Koneksi ke database (contoh dengan SQLite)

db, err := sql.Open("sqlite3", "test.db")
if err != nil {
log.Fatal(err)
}
// Endpoint untuk mengambil data dari database
e.GET("/getdata", func(c echo.Context) error {
// Query sederhana untuk mendapatkan data
rows, err := db.Query("SELECT * FROM example_table")
if err != nil {
log.Fatal(err)
}
defer rows.Close()
var result string

for rows.Next() {
var name string
if err := rows.Scan(&name); err != nil {
log.Fatal(err)
}
result += name + "\n"
}
return c.String(http.StatusOK, result)

})
e.Start(":8080")
}
Dalam contoh di atas, aplikasi menggunakan database SQLite tanpa menerapkan pengaturan
keamanan yang memadai. Penyerang dapat memanfaatkan kelemahan ini untuk menyusup ke
dalam sistem atau merusak data. Sebagai langkah pencegahan, pengembang harus
mengimplementasikan langkah-langkah keamanan seperti penggunaan parameterized queries,
validasi input, dan konfigurasi database yang lebih aman.
Denial of Service (DoS) and Distributed Denial of Service (DDoS)

Denial of Service (DoS) dan Distributed Denial of Service (DDoS) merupakan tipe-tipe risiko
keamanan yang dapat mengancam aplikasi back-end berbasis Golang, termasuk menggunakan
framework seperti Echo. DoS adalah serangan yang bertujuan untuk membuat layanan atau
aplikasi menjadi tidak tersedia dengan cara membanjiri sumber daya yang ada, seperti
bandwidth atau penggunaan CPU. DDoS, sementara itu, melibatkan penggunaan banyak sumber
daya yang tersebar untuk melancarkan serangan DoS.
Dalam konteks Golang dan Echo, risiko DoS dan DDoS dapat muncul melalui serangan terhadap
endpoint tertentu atau bahkan infrastruktur keseluruhan. Contoh paling sederhana adalah
serangan HTTP flooding, di mana sejumlah besar permintaan HTTP palsu atau tidak sah
dikirimkan ke server, menghabiskan sumber daya dan membuatnya tidak responsif.
Untuk melindungi aplikasi Golang dan Echo dari risiko ini, beberapa langkah pencegahan dapat
diambil. Pertama, implementasikan mekanisme rate limiting pada endpoint yang rentan
terhadap serangan DoS. Ini dapat dilakukan dengan menggunakan middleware atau library
khusus untuk mengatur jumlah permintaan yang dapat diterima dalam interval waktu tertentu.
Contoh kode sederhana untuk menerapkan rate limiting pada Echo dengan menggunakan library
github.com/labstack/echo-contrib/ratelimiter adalah sebagai berikut:
package main
import (
"github.com/labstack/echo-contrib/ratelimiter"
)
func main() {
e := echo.New()
// Set up rate limiting middleware

limiter := ratelimiter.New(ratelimiter.WithMaxHits(10),
ratelimiter.WithTimeWindow(1))
e.Use(middleware.RateLimiterWithConfig(limiter))
// Define your routes and handlers

return c.String(200, "Hello, World!")
})
// Start the server

e.Start(":8080")
}
Dalam contoh ini, WithMaxHits(10) menunjukkan bahwa hanya 10 permintaan dapat
diterima dalam satu detik, dan WithTimeWindow(1) mengatur jendela waktu untuk melacak
hit per detik.
Penting untuk selalu memperbarui dan memonitor keamanan aplikasi, termasuk menerapkan
tindakan pencegahan yang relevan terhadap serangan DoS dan DDoS untuk menjaga
ketersediaan dan keandalan sistem.
HTTPS vs HTTP
Duration: 60:00
Statelessness dan Implikasi HTTP

Statelessness mengacu pada karakteristik di mana server tidak menyimpan status atau
informasi tentang keadaan klien antara dua permintaan. Dalam konteks protokol HTTP, ini
berarti setiap permintaan yang diterima oleh server dianggap sebagai permintaan yang mandiri
tanpa adanya pengetahuan tentang permintaan sebelumnya. Stateless design memungkinkan
aplikasi untuk lebih mudah di-maintain, dapat di-cache, dan scalable. Keuntungan utama dari
statelessness adalah server tidak perlu menyimpan informasi klien, yang dapat mengurangi
beban server dan meningkatkan kinerja aplikasi.
Implikasi HTTP pada HTTPS vs HTTP pada keamanan aplikasi backend Golang dengan Echo
sangat signifikan. HTTPS (Hypertext Transfer Protocol Secure) adalah versi aman dari HTTP
yang menggunakan enkripsi SSL/TLS untuk melindungi integritas dan kerahasiaan data yang
ditransmisikan antara klien dan server. Jika aplikasi backend Golang menggunakan protokol
HTTP tanpa enkripsi (tidak menggunakan HTTPS), data yang dikirimkan antara klien dan server
dapat rentan terhadap serangan man-in-the-middle, di mana pihak ketiga dapat mengakses atau
memanipulasi data secara tidak sah.
Berikut adalah contoh kode sederhana menggunakan Echo, framework web Golang, untuk
membuat server HTTP dan HTTPS:
package main
import (
"net/http"
)
func main() {
e := echo.New()
// Endpoint untuk HTTP

e.GET("/hello", func(c echo.Context) error {
return c.String(http.StatusOK, "Hello, HTTP!")
})
// Endpoint untuk HTTPS

e.GET("/secure-hello", func(c echo.Context) error {
return c.String(http.StatusOK, "Hello, HTTPS!")
})
// Mulai server HTTP pada port 8080

go func() {
if err := e.Start(":8080"); err != nil {
e.Logger.Info("Server HTTP berhenti")
}
}()
// Mulai server HTTPS pada port 8443 dengan sertifikat TLS

if err := e.StartTLS(":8443", "cert.pem", "key.pem"); err
!= nil {
e.Logger.Info("Server HTTPS berhenti")
}
}
Dalam contoh di atas, server Echo memiliki dua endpoint: satu untuk HTTP (/hello) dan satu
untuk HTTPS (/secure-hello). Untuk server HTTPS, kita menggunakan sertifikat TLS dengan
pemanggilan StartTLS. Pastikan kita memiliki sertifikat TLS yang valid (ganti "cert.pem" dan
"key.pem" dengan lokasi sertifikat dan kunci kita).
Menggunakan HTTPS pada aplikasi backend Golang sangat penting untuk meningkatkan
keamanan dan melindungi data yang ditransmisikan antara klien dan server. Itu memastikan
bahwa informasi sensitif tidak dapat diakses oleh pihak yang tidak sah saat berpindah melalui
jaringan.
Faedah Kepentingan Komunikasi dengan HTTPS

Protokol HTTPS (Hypertext Transfer Protocol Secure) memberikan banyak faedah dan
kepentingan dibandingkan dengan HTTP (Hypertext Transfer Protocol) dalam konteks
keamanan aplikasi web, terutama pada bagian back-end yang menggunakan Golang dan Echo
sebagai framework-nya. HTTPS menyediakan lapisan keamanan tambahan dengan menerapkan
enkripsi data yang dikirimkan antara server dan klien menggunakan protokol SSL/TLS. Dengan
menggunakan HTTPS, informasi yang dikirimkan antara klien dan server menjadi terenkripsi,
sehingga sulit bagi pihak yang tidak berwenang untuk memahami atau mengubah data
tersebut.
Selain itu, HTTPS juga memberikan kepercayaan kepada pengguna melalui tanda keamanan
yang terlihat pada browser, seperti ikon gembok atau indikator "secure" yang menunjukkan
bahwa koneksi aman. Hal ini dapat meningkatkan kepercayaan pengguna terhadap aplikasi,
terutama dalam hal mengelola informasi sensitif seperti kata sandi atau data transaksi.
Secara khusus dalam lingkup back-end Golang dengan menggunakan framework Echo,
implementasi HTTPS dapat dilakukan dengan menyediakan sertifikat SSL dan menggunakan
fungsi-fungsi yang disediakan oleh Golang dan Echo. Berikut adalah contoh kode sederhana
untuk mengaktifkan HTTPS pada Echo:
package main
import (
"fmt"
"net/http"
)
func main() {
e := echo.New()
// Middleware untuk force HTTPS
e.Pre(middleware.HTTPSRedirect())
// Route sederhana
return c.String(http.StatusOK, "Hello, HTTPS World!")
})
// Menjalankan server HTTPS

err := e.StartTLS(":443", "path/to/cert.pem",
"path/to/key.pem")
if err != nil {
}
}
Dalam contoh kode di atas, middleware HTTPSRedirect digunakan untuk memaksa

pengguna untuk menggunakan protokol HTTPS. Selain itu, StartTLS digunakan untuk
menjalankan server dengan dukungan TLS, dengan menyediakan path ke file sertifikat dan kunci
pribadi.
Secara keseluruhan, menggunakan HTTPS pada aplikasi web back-end Golang dengan Echo
bukan hanya memberikan lapisan keamanan tambahan, tetapi juga memberikan kepercayaan
dan kenyamanan kepada pengguna, menjadikannya pilihan yang sangat dianjurkan untuk
aplikasi yang menangani data sensitif.
Man-in-the-Middle attacks
Serangan Man-in-the-Middle (MITM) adalah teknik serangan di mana seorang penyerang
mencoba untuk menyisipkan dirinya di antara dua pihak yang berkomunikasi secara langsung,
seperti antara pengguna dan server. Dalam konteks keamanan aplikasi web back-end
menggunakan bahasa pemrograman Golang dan framework Echo, serangan MITM dapat terjadi
jika komunikasi antara klien dan server tidak dienkripsi dengan baik.
Dalam kasus aplikasi back-end Golang dan Echo, serangan MITM dapat merusak integritas data
dan keamanan informasi yang dikirim antara klien dan server. Penyerang dapat menggunakan
berbagai teknik, seperti sniffing (penyadapan) atau injection (penyisipan), untuk membaca atau
memanipulasi data yang dikirimkan antara kedua pihak.
Salah satu cara untuk melindungi aplikasi dari serangan MITM adalah dengan
mengimplementasikan HTTPS untuk enkripsi data yang dikirimkan antara klien dan server.
Penggunaan HTTPS memastikan bahwa data yang dikirimkan tidak dapat dengan mudah
dibaca atau dimanipulasi oleh pihak yang tidak sah.
Contoh kode sederhana menggunakan Golang dan Echo untuk mengimplementasikan HTTPS
dalam aplikasi web dapat dilihat di bawah ini:
package main
import (
"net/http"
)
func main() {
e := echo.New()
// Middleware untuk mengaktifkan HTTPS

e.Use(middleware.HTTPSRedirect())
// Routes
return c.String(http.StatusOK, "Hello, Secure World!")
})
// Start server
e.Start(":8080")
}
Pada contoh kode di atas, middleware HTTPSRedirect() digunakan untuk mengarahkan lalu
lintas HTTP ke HTTPS, sehingga memastikan bahwa komunikasi antara klien dan server
dienkripsi. Pastikan juga untuk menyertakan sertifikat SSL/TLS yang valid untuk mengaktifkan
HTTPS dengan aman.
Dengan menerapkan langkah-langkah keamanan seperti enkripsi HTTPS, aplikasi web back-end
Golang dan Echo dapat melindungi diri dari potensi serangan Man-in-the-Middle, menjaga
keutuhan dan kerahasiaan data yang dikirimkan antara klien dan server.
Eavesdropping dan Data Interception
Eavesdropping dan data interception merupakan dua ancaman keamanan yang sering kali
menjadi fokus dalam konteks keamanan aplikasi web, terutama pada bagian back-end.
Eavesdropping merujuk pada kegiatan memantau atau mendengarkan percakapan atau data
yang dikirimkan antara dua entitas tanpa izin. Sementara data interception berkaitan dengan
upaya mengakses atau mencuri data yang dikirimkan melalui jaringan, yang dapat terjadi baik
secara aktif maupun pasif.
Dalam konteks keamanan aplikasi back-end yang menggunakan bahasa pemrograman Golang
dan framework Echo, perlu diambil langkah-langkah khusus untuk mencegah eavesdropping
dan data interception. Salah satu pendekatan yang umum digunakan adalah penggunaan
protokol HTTPS untuk mengamankan komunikasi antara klien dan server dengan enkripsi.
Golang dan Echo menyediakan dukungan untuk HTTPS dengan mudah.
Contoh kode sederhana untuk menggunakan HTTPS dengan Golang dan Echo:
package main
import (
"net/http"
)
func main() {
e := echo.New()
// Middleware untuk menangani HTTPS

e.Use(func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
req := c.Request()
if req.URL.Scheme != "https" &&
req.Header.Get("X-Forwarded-Proto") != "https" {
// Redirect ke HTTPS jika bukan protokol
HTTPS
return
c.Redirect(http.StatusMovedPermanently,
"https://"+req.Host+req.RequestURI)
}
return next(c)
}
})

return c.String(http.StatusOK, "Hello, World!")
})
// Menjalankan server dengan HTTPS

e.StartTLS(":443", "cert.pem", "key.pem")
}
Contoh di atas menggunakan Echo untuk membuat server sederhana dengan satu endpoint
("/"). Middleware ditambahkan untuk memeriksa apakah koneksi menggunakan protokol
HTTPS. Jika tidak, pengguna akan diarahkan ke versi HTTPS. Fungsi StartTLS digunakan
untuk memulai server dengan dukungan TLS, yang akan mengamankan komunikasi dengan
enkripsi.
Penting untuk dicatat bahwa sertifikat TLS yang valid (seperti yang disediakan oleh otoritas
sertifikasi terpercaya) harus digunakan dalam produksi. Sertifikat cert.pem dan kunci pribadi
key.pem dalam contoh ini hanyalah contoh dan seharusnya tidak digunakan secara langsung
dalam lingkungan produksi.
Keunggulan HTTPS dan Manfaat HTTP/2

Keunggulan HTTPS dan manfaat HTTP/2 memiliki peran krusial dalam meningkatkan
keamanan dan kinerja aplikasi back-end berbasis Golang, terutama yang menggunakan
framework Echo. HTTPS, atau Hypertext Transfer Protocol Secure, menyediakan lapisan
keamanan dengan mengenkripsi data yang dikirim antara server dan klien. Kelebihan utama
HTTPS adalah kemampuannya untuk melindungi integritas dan kerahasiaan data, mencegah
serangan seperti man-in-the-middle, serta memberikan keyakinan kepada pengguna bahwa
mereka terhubung dengan sumber yang aman. Ini sangat penting dalam konteks aplikasi
back-end Golang, di mana keamanan data menjadi prioritas utama.
Sementara itu, manfaat HTTP/2 pada aspek kinerja juga sangat signifikan. Protokol ini
memperkenalkan fitur-fitur seperti multiplexing, header compression, dan server push, yang
secara kolektif meningkatkan efisiensi dan kecepatan transfer data. Dengan HTTP/2, aplikasi
back-end Golang yang menggunakan framework Echo dapat mengoptimalkan penggunaan
sumber daya, mengurangi latensi, dan mempercepat waktu muat halaman. Ini tidak hanya
meningkatkan pengalaman pengguna secara keseluruhan tetapi juga mendukung efisiensi lalu
lintas data, yang menjadi kritis dalam aplikasi modern yang sering kali memerlukan penanganan
simultan yang cepat terhadap permintaan dari banyak klien.
Sehingga, manfaat HTTP/2 memberikan peningkatan performa yang signifikan dibandingkan

HTTP/1.1. HTTP/2 memungkinkan multiplexing, artinya banyak permintaan dan tanggapan
dapat dikirim secara bersamaan melalui satu koneksi. Ini mengurangi latensi dan meningkatkan
efisiensi penggunaan sumber daya. Selain itu, fitur-fitur seperti header compression dan server
push membantu mengoptimalkan kecepatan transfer data, menghasilkan pengalaman
pengguna yang lebih responsif.
package main
import (
"net/http"
)
func main() {
e := echo.New()
// Middleware untuk mengaktifkan HTTPS

e.Use(middleware.HTTPSRedirect())
// Handler untuk route "/"

return c.String(http.StatusOK, "Hello, HTTPS!")
})
// Menjalankan server pada port 443 dengan sertifikat TLS

}
Contoh kode sederhana untuk menggunakan HTTP/2 dengan Echo:
package main
import (
"golang.org/x/net/http2"
"net/http"
)
func main() {
e := echo.New()
// Konfigurasi HTTP/2
e.Server.Addr = ":8080"
e.Server.TLSConfig = &http2.Server{}
// Handler untuk route "/"

return c.String(http.StatusOK, "Hello, HTTP/2!")
})
// Menjalankan server dengan HTTP/2

}
Dengan mengintegrasikan HTTPS dan HTTP/2 dalam aplikasi back-end Golang berbasis Echo,
pengembang dapat mencapai kombinasi keamanan dan kinerja yang optimal. Data yang
dienkripsi oleh HTTPS melindungi informasi sensitif, sementara fitur HTTP/2 meningkatkan
efisiensi dan kecepatan transfer data. Secara bersamaan, hal ini menciptakan lingkungan yang
lebih aman dan responsif, mendukung aplikasi untuk memberikan pengalaman pengguna yang
superior sambil menjaga integritas dan keamanan informasi.
Cross-Origin Resource Sharing (CORS)
Duration: 75:00
Memahami Cross-Origin Resource Sharing (CORS)

Cross-Origin Resource Sharing (CORS) adalah mekanisme keamanan yang diterapkan oleh
browser web untuk mengontrol bagaimana dokumen atau sumber daya web di suatu domain
dapat diakses oleh halaman web yang berasal dari domain lain.
Pada aplikasi back-end yang menggunakan bahasa pemrograman Golang dan framework Echo,
implementasi CORS menjadi krusial untuk memastikan keamanan dan integritas data. Golang
menyediakan dukungan yang baik untuk mengelola CORS melalui pustaka standar net/http, dan
Echo, sebagai framework web yang ringan dan tangguh, memfasilitasi penanganan CORS
dengan mudah.
Saat sebuah permintaan HTTP dilakukan dari sebuah halaman web di domain A ke server
back-end di domain B, browser akan memicu aturan keamanan CORS. Konfigurasi CORS pada
aplikasi Golang-Echo melibatkan penambahan header HTTP seperti
"Access-Control-Allow-Origin" untuk menentukan domain mana yang diperbolehkan mengakses
sumber daya, "Access-Control-Allow-Methods" untuk menentukan metode HTTP yang diizinkan,
dan header lainnya sesuai kebutuhan.
Dengan memahami dan mengimplementasikan CORS dengan benar, aplikasi back-end Golang
dan Echo dapat memastikan interaksi yang aman dan terkendali antara berbagai domain,
meningkatkan keamanan serta menghindari potensi risiko keamanan seperti serangan CSRF
(Cross-Site Request Forgery) atau penyusupan data lintas domain.
Troubleshooting CORS Issues

Cross-Origin Resource Sharing (CORS) merupakan mekanisme keamanan pada aplikasi web
yang bertujuan untuk melindungi pengguna dari potensi ancaman keamanan yang muncul
akibat permintaan sumber daya lintas domain. Salah satu permasalahan utama CORS adalah
kebijakan same-origin yang diterapkan oleh browser, yang mencegah permintaan sumber daya
dari domain yang berbeda. Kendala ini dapat menjadi hambatan saat mengembangkan aplikasi
web yang mengandalkan integrasi dengan server atau layanan dari domain eksternal.
Salah satu permasalahan CORS umum adalah kesulitan dalam melakukan permintaan AJAX
lintas domain. Saat aplikasi web mencoba mengakses sumber daya dari domain yang berbeda,
browser akan memblokir permintaan tersebut untuk mencegah potensi ancaman keamanan.
Selain itu, masalah dapat muncul saat mencoba mengirim permintaan dengan metode HTTP
yang tidak diizinkan atau ketika header yang diperlukan tidak disertakan dalam permintaan.
Penyelesaian untuk permasalahan CORS melibatkan konfigurasi server back-end untuk

mengizinkan permintaan dari domain tertentu. Ini dapat dilakukan dengan menambahkan
header HTTP khusus, yaitu "Access-Control-Allow-Origin", yang menyatakan domain mana yang
diizinkan untuk mengakses sumber daya. Selain itu, konfigurasi dapat mencakup penanganan
metode HTTP, header tambahan, serta manajemen cookies.
Selain header "Access-Control-Allow-Origin", ada juga header lain seperti

"Access-Control-Allow-Methods" dan "Access-Control-Allow-Headers" yang dapat dikonfigurasi
untuk mengizinkan metode HTTP dan header tertentu. Penggunaan token CSRF (Cross-Site
Request Forgery) juga dapat membantu mengatasi permasalahan keamanan yang mungkin
muncul akibat mengizinkan permintaan lintas domain.
Dengan konfigurasi yang tepat pada sisi server, aplikasi web dapat berfungsi secara optimal
tanpa mengorbankan keamanan. Penting untuk memahami dan menerapkan kebijakan CORS
secara bijak, agar interaksi lintas domain dapat dilakukan dengan aman dan terkendali dalam
lingkungan web yang semakin kompleks dan terhubung secara luas.
CORS Headers
CORS, atau Cross-Origin Resource Sharing, adalah kebijakan keamanan yang diterapkan oleh
browser web untuk memastikan bahwa halaman web hanya dapat mengakses sumber daya dari
domain yang sama dengan halaman tersebut. Pembatasan ini bertujuan untuk mencegah
serangan lintas situs (cross-site scripting) dan melindungi pengguna dari potensi ancaman
keamanan. CORS Headers adalah bagian penting dari implementasi kebijakan CORS, dan
mereka memungkinkan atau menolak permintaan lintas domain.
Pada aplikasi back-end Golang dengan framework Echo, kita dapat mengonfigurasi CORS
Headers dengan mudah. Echo menyediakan middleware CORS yang mempermudah
penanganan aspek keamanan ini. Dengan menambahkan middleware CORS pada server Echo,
kita dapat mengontrol sumber daya apa yang dapat diakses dari domain lintas dan jenis
permintaan apa yang diperbolehkan.
Pertama, kita perlu mengonfigurasi middleware CORS di aplikasi Echo kita. Middleware ini
membantu menangani permintaan CORS dengan menambahkan header yang diperlukan ke
respons HTTP. Berikut adalah contoh konfigurasi CORS pada aplikasi web backend Golang
menggunakan Echo:
package main
import (
)
func main() {
// Inisialisasi Echo
e := echo.New()
// Konfigurasi middleware CORS

e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
AllowOrigins: []string{"http://example.com",
"https://example.com"},
AllowMethods: []string{echo.GET, echo.HEAD, echo.PUT,
echo.PATCH, echo.POST, echo.DELETE},
}))
// Registrasi route atau endpoint lainnya di sini
// Start server
e.Start(":8080")
}
Dalam contoh kode di atas, AllowOrigins menentukan domain yang diizinkan untuk
membuat permintaan CORS ke server kita. kita dapat menentukan lebih dari satu domain
dengan menyertakan mereka dalam slice. AllowMethods menentukan metode HTTP mana
yang diizinkan oleh permintaan CORS.
Penting untuk dicatat bahwa kita harus mengganti nilai-nilai dalam contoh kode tersebut sesuai
dengan kebutuhan dan kebijakan keamanan aplikasi kita. Selain itu, pastikan untuk
menyesuaikan middleware CORS sesuai dengan kebutuhan spesifik aplikasi dan izinkan hanya
domain yang diperlukan agar dapat membuat permintaan ke backend kita.
Same-Origin Policy
Same-Origin Policy (SOP) adalah prinsip keamanan yang diterapkan oleh browser web untuk
membatasi akses JavaScript dari halaman web ke sumber daya di domain lain. Tujuannya
adalah mencegah potensi ancaman keamanan seperti serangan Cross-Site Scripting (XSS) dan
Cross-Site Request Forgery (CSRF). SOP memastikan bahwa sebuah skrip yang dijalankan di
suatu halaman web hanya memiliki akses ke sumber daya pada domain yang sama dengan
halaman tersebut, termasuk protokol, port, dan subdomain.
Ketika kita berbicara tentang aplikasi back-end menggunakan Golang dan Echo, penting untuk
memahami bahwa SOP adalah pertimbangan keamanan yang lebih relevan untuk pengembang
front-end. Meskipun Golang dan Echo dapat berkontribusi pada keamanan aplikasi secara
keseluruhan, implementasi SOP biasanya dilakukan di sisi klien, yaitu pada bagian front-end.
Contoh implementasi SOP dalam Golang dan Echo biasanya melibatkan penyisipan header
HTTP yang tepat pada respons yang dikirim oleh server. Berikut adalah contoh sederhana
menggunakan Echo:
package main
import (
"net/http"
)
func main() {
e := echo.New()
// Middleware untuk menambahkan header yang mematuhi

Same-Origin Policy
AllowOrigins: []string{"https://domain-anda.com"},
AllowMethods: []string{http.MethodGet,
http.MethodPut, http.MethodPost, http.MethodDelete},
}))
// Route contoh
// Logika bisnis kita di sini
return c.JSON(http.StatusOK,
map[string]interface{}{"message": "Data berhasil diambil"})
})
// Mulai server
e.Start(":8080")
}
Dalam contoh ini, kita menggunakan middleware CORS dari Echo untuk menambahkan header
yang sesuai dengan kebijakan SOP. AllowOrigins menentukan domain mana yang diizinkan
untuk mengakses sumber daya, dan AllowMethods menentukan metode HTTP mana yang
diizinkan.
Namun, SOP sebagian besar merupakan pertimbangan di sisi front-end. Klien (browser) yang
menjalankan JavaScript perlu mematuhi SOP. Implementasi di sisi server, termasuk di Golang
dan Echo, lebih berfokus pada praktik keamanan umum seperti sanitasi input, validasi, dan
perlindungan terhadap serangan XSS dan CSRF.
Simple Requests
Simple Requests merujuk pada permintaan HTTP yang dianggap sederhana oleh browser,
seperti GET, POST, atau HEAD, dan tidak menyertakan metode seperti PUT atau DELETE yang
dapat memicu permintaan lintas situs (cross-origin).
CORS adalah mekanisme keamanan yang diterapkan oleh browser untuk mengontrol akses
sumber daya di antara dua domain yang berbeda. Ketika aplikasi front-end dijalankan di domain
yang berbeda dengan back-end, browser akan memblokir permintaan lintas situs secara default
untuk melindungi pengguna dari potensi serangan keamanan.
Untuk mengatasi pembatasan CORS, back-end Golang dengan framework Echo dapat
mengimplementasikan middleware CORS. Middleware CORS di Echo dapat diaktifkan dengan
mengimpor package "github.com/labstack/echo/middleware" dan menambahkannya ke
aplikasi Echo sebagai middleware. Berikut adalah contoh kode sederhana yang
menggambarkan implementasi Simple Requests dan CORS pada aplikasi back-end Golang
dengan Echo:
package main
import (
"net/http"
)
func main() {
e := echo.New()
// Middleware CORS
// Route untuk Simple Request

return c.String(http.StatusOK, "Ini adalah data yang
diakses melalui Simple Request")
})
// Route untuk Complex Request (contoh metode PUT)

e.PUT("/update", func(c echo.Context) error {
return c.String(http.StatusOK, "Ini adalah data yang
diupdate melalui Complex Request")
})
// Mulai server Echo pada port 8080

e.Start(":8080")
}
Dalam contoh kode di atas, middleware CORS dari Echo diaktifkan dengan
e.Use(middleware.CORS()), yang secara default mengizinkan semua sumber (origin)
untuk mengakses sumber daya back-end. kita dapat menyesuaikan konfigurasi CORS sesuai
kebutuhan aplikasi kita.
Penting untuk dicatat bahwa konfigurasi CORS yang lemah dapat membuka celah keamanan.
Oleh karena itu, perlu dipertimbangkan dengan hati-hati dan mungkin membatasi akses hanya
kepada domain atau sumber daya yang diperlukan untuk aplikasi kita.
Preflight Requests
Preflight Requests adalah salah satu aspek penting dari CORS, yang merupakan permintaan
HTTP tambahan yang dikirim oleh browser sebelum melakukan permintaan aktual (actual
request) ke server lintas asal.
Preflight Requests dibutuhkan ketika permintaan melibatkan metode HTTP tertentu, seperti
PUT, DELETE, atau metode selain metode sederhana (simple methods) seperti GET, POST,
HEAD. Selain itu, Preflight Requests juga akan dihasilkan jika permintaan melibatkan header
kustom atau menggunakan metode konten jenis media yang tidak termasuk dalam jenis konten
media yang diizinkan secara sederhana.
Untuk mengelola Preflight Requests pada aplikasi back-end Golang dengan menggunakan
framework Echo, kita perlu menanggapi permintaan Preflight dengan benar. Ini dapat dicapai
dengan menambahkan middleware CORS yang sesuai dalam aplikasi Echo kita. Berikut contoh
kode sederhana:
package main
import (
)
func main() {
e := echo.New()
// Middleware CORS untuk menangani Preflight Requests

AllowOrigins: []string{"*"}, // Atur sesuai kebutuhan
aplikasi kita
AllowHeaders: []string{echo.HeaderOrigin,
echo.HeaderContentType, echo.HeaderAccept},
AllowMethods: []string{http.MethodGet, http.MethodPut,
http.MethodPost, http.MethodDelete},
}))
// Route contoh
})
// Mulai server Echo

e.Start(":8080")
}
Pada contoh di atas, kita menggunakan middleware CORSWithConfig dari Echo untuk
menangani Preflight Requests. Konfigurasi CORS ditetapkan dengan menyertakan AllowOrigins,
AllowHeaders, dan AllowMethods sesuai kebutuhan aplikasi kita. Middleware ini akan
memberikan tanggapan CORS yang benar saat menerima Preflight Requests dan
memungkinkan permintaan sebenarnya untuk dilakukan setelahnya.
Pastikan untuk menyesuaikan konfigurasi CORS sesuai dengan kebutuhan keamanan aplikasi
kita. Menggunakan middleware CORS ini membantu mencegah masalah CORS terkait Preflight
Requests dan memastikan aplikasi back-end Golang dengan Echo berfungsi dengan benar saat
diakses dari asal yang berbeda.
Implementasi API Security CORS dengan Echo

CORS diperlukan untuk mengontrol akses lintas domain pada permintaan HTTP oleh browser,
yang dapat membantu mencegah potensi ancaman keamanan seperti serangan CSRF dan
kebocoran informasi. Echo, sebagai framework web Golang yang ringan dan fleksibel,
menyediakan kemudahan dalam mengimplementasikan kebijakan CORS.
Untuk menerapkan keamanan CORS pada aplikasi back-end menggunakan Echo, langkah
pertama adalah mengonfigurasi middleware CORS di dalam aplikasi. Middleware CORS
membantu menetapkan aturan yang memungkinkan atau membatasi permintaan HTTP dari
domain yang berbeda. Berikut adalah contoh implementasi sederhana dengan Echo:
package main
import (
)
func main() {
// Inisialisasi objek Echo
e := echo.New()
// Middleware CORS untuk mengatur kebijakan CORS

AllowOrigins: []string{"https://example.com"}, // Ganti
dengan domain yang diizinkan
}))
// Tambahkan handler untuk rute tertentu

return c.String(200, "Halo, dunia!")
})
// Mulai server Echo

e.Start(":8080")
}
Pada contoh kode di atas, middleware CORS disetup dengan konfigurasi dasar, termasuk
domain yang diizinkan (AllowOrigins) dan metode HTTP yang diizinkan (AllowMethods).
kita dapat menyesuaikan aturan sesuai dengan kebutuhan aplikasi kita.
Penjelasan singkat untuk konfigurasi middleware CORS:
● AllowOrigins: Menentukan domain yang diizinkan untuk mengakses sumber daya.

● AllowMethods: Menentukan metode HTTP yang diizinkan untuk permintaan lintas
domain.
Dengan mengintegrasikan middleware CORS ini ke dalam aplikasi Echo kita, kita dapat
meningkatkan keamanan aplikasi dan memastikan bahwa permintaan HTTP dari domain yang
tidak diizinkan tidak diterima. Jangan lupa untuk mengganti domain di AllowOrigins sesuai
dengan kebutuhan aplikasi kita.
Handling CORS pada RESTful APIs
Cross-Origin Resource Sharing (CORS) adalah mekanisme keamanan pada web yang
mengontrol bagaimana aplikasi web di suatu domain dapat mengakses sumber daya (seperti
data, layanan, atau API) yang berada di domain lain. Ini menjadi sangat penting ketika kita
mengembangkan aplikasi back-end menggunakan Golang dan Echo framework yang
menyediakan RESTful APIs.
Untuk menangani CORS pada aplikasi back-end Golang dengan Echo, kita perlu mengizinkan
permintaan lintas domain dari sumber tertentu. Ini dilakukan dengan menambahkan header
CORS yang sesuai pada respons HTTP dari server. Pada dasarnya, kita perlu menentukan
sumber-sumber yang diizinkan (origin), metode HTTP yang diizinkan, serta header yang
diizinkan.
Berikut adalah contoh kode sederhana untuk menangani CORS pada aplikasi back-end Golang
dengan Echo:
package main
import (
)
func main() {
e := echo.New()
// Middleware untuk menangani CORS

AllowOrigins: []string{"http://localhost:3000"}, //
Ganti dengan origin kita
AllowHeaders: []string{echo.HeaderOrigin,
echo.HeaderContentType, echo.HeaderAccept},
}))
// Handler untuk route

e.GET("/api/data", func(c echo.Context) error {
// Logika handler API
return c.JSON(http.StatusOK,
map[string]interface{}{"message": "Hello, CORS is handled!"})
})
// Start server
e.Start(":8080")
}
Pada contoh di atas, middleware CORSWithConfig dari Echo digunakan untuk menangani
CORS. kita perlu mengkonfigurasi opsi-opsi CORS, seperti AllowOrigins untuk menentukan
origin yang diizinkan, AllowMethods untuk menentukan metode HTTP yang diizinkan, dan
AllowHeaders untuk menentukan header yang diizinkan.
Pastikan untuk mengganti nilai-nilai tersebut sesuai dengan kebutuhan dan konfigurasi aplikasi
kita. Dengan menambahkan middleware CORS ini, aplikasi back-end kita akan dapat menerima
permintaan dari origin yang diizinkan tanpa masalah CORS.
Cross-Site Request Forgery (CSRF) Prevention

Duration: 75:00
Memahami Cross-Site Request Forgery (CSRF) Prevention

Cross-Site Request Forgery (CSRF) merupakan jenis serangan keamanan pada aplikasi web
yang memanfaatkan otentikasi yang sudah ada antara pengguna dan aplikasi. Serangan ini
terjadi ketika seorang penyerang memaksa pengguna yang sudah diautentikasi untuk
melakukan aksi tertentu tanpa sepengetahuan atau izin mereka. Untuk mencegah CSRF, aplikasi
back-end perlu mengimplementasikan mekanisme keamanan yang efektif.
Salah satu cara pencegahan CSRF yang umum digunakan adalah dengan menggunakan token
CSRF. Token ini biasanya disematkan dalam formulir web atau sebagai header dalam setiap
permintaan yang memerlukan otentikasi. Saat pengguna mengirimkan permintaan, aplikasi
memeriksa keberadaan dan kecocokan token CSRF untuk memastikan bahwa permintaan
berasal dari pengguna yang sah dan tidak dari serangan CSRF.
Selain itu, penggunaan SameSite cookie attribute juga menjadi langkah pencegahan yang
signifikan. Dengan mengatur SameSite pada cookie, pengembang dapat mengontrol kapan
browser mengirim cookie dalam permintaan lintas situs. Pengaturan yang tepat dapat
mencegah browser mengirim cookie pada permintaan yang diinisiasi oleh situs lain, mengurangi
risiko CSRF.
Selain teknik tersebut, perlu juga untuk mengimplementasikan kebijakan keamanan yang ketat
pada sisi server. Validasi setiap permintaan, termasuk memastikan bahwa permintaan yang
dikirimkan sesuai dengan kebijakan aplikasi dan pengguna yang sedang diautentikasi, menjadi
langkah penting dalam melindungi aplikasi dari serangan CSRF.
Pentingnya pemahaman dan implementasi mekanisme pencegahan CSRF tidak hanya

meningkatkan keamanan aplikasi, tetapi juga memberikan kepercayaan kepada pengguna
bahwa informasi mereka aman. Dengan menggabungkan beberapa lapisan keamanan seperti
token CSRF, SameSite cookie attribute, dan validasi server, aplikasi back-end dapat
meminimalkan risiko terjadinya serangan CSRF dan meningkatkan tingkat keamanan secara
keseluruhan.
Synchronizer Token Pattern (STP)

Synchronizer Token Pattern (STP) merupakan salah satu metode yang digunakan dalam
pencegahan Cross-Site Request Forgery (CSRF) pada aplikasi web. CSRF adalah serangan
keamanan di mana seorang penyerang dapat memaksa pengguna untuk melakukan tindakan
tertentu tanpa persetujuan mereka. STP bertujuan untuk mengatasi masalah ini dengan
memasukkan token khusus ke dalam setiap permintaan yang dibuat oleh pengguna dan
memvalidasi token tersebut di sisi server.
Dalam implementasi dengan Golang dan Echo framework, kita dapat menggunakan STP dengan
langkah-langkah berikut:
Generate Token
Pertama, kita perlu membuat fungsi untuk menghasilkan token dan menyimpannya dalam
cookie atau menyematkannya dalam formulir setiap kali pengguna mengakses halaman.
package main
import (
"crypto/rand"
"encoding/base64"
"net/http"
)
// generateCSRFToken menghasilkan token CSRF acak

func generateCSRFToken() (string, error) {
token := make([]byte, 32)
_, err := rand.Read(token)
if err != nil {
return "", err
}
return base64.URLEncoding.EncodeToString(token), nil
}
func main() {
e := echo.New()
// Middleware untuk mengatur token CSRF pada setiap permintaan

TokenLookup: "form:csrf_token",
}))

// Menghasilkan token CSRF dan menyematkannya pada
halaman
token, err := generateCSRFToken()
if err != nil {
return err
}
return c.Render(http.StatusOK, "index.html",
map[string]interface{}{
"csrf_token": token,
})
})
// Handler untuk mengelola permintaan formulir

e.POST("/submit", func(c echo.Context) error {
// Melakukan validasi token CSRF
if err := c.Validate(csrf.Token); err != nil {
return echo.ErrForbidden
}
// Proses formulir
return c.String(http.StatusOK, "Formulir berhasil
dikirim!")
})
e.Logger.Fatal(e.Start(":8080"))
}
Validasi Token
Pada handler yang menangani permintaan POST, kita perlu memvalidasi token CSRF yang
dikirimkan oleh pengguna.

// Melakukan validasi token CSRF
if err := c.Validate(csrf.Token); err != nil {
return echo.ErrForbidden
}
// Proses formulir
return c.String(http.StatusOK, "Formulir berhasil dikirim!")
})
Dengan menerapkan langkah-langkah ini, kita dapat meningkatkan keamanan aplikasi web
back-end kita dengan menggunakan Synchronizer Token Pattern untuk pencegahan CSRF. Kode
sumber di atas memanfaatkan Echo framework untuk memudahkan pengelolaan token CSRF
dan validasinya.
SameSite Cookies attribute

SameSite adalah atribut yang digunakan dalam cookie HTTP untuk mengontrol bagaimana
cookie harus diatur terhadap permintaan lintas situs (cross-site request). Atribut ini
dimanfaatkan dalam konteks pencegahan Cross-Site Request Forgery (CSRF) untuk
meningkatkan keamanan aplikasi web back-end. Dengan menggunakan SameSite, pengembang
dapat mengendalikan kapan dan bagaimana cookie dikirim dalam permintaan lintas situs.
SameSite Cookies attribute memungkinkan pengembang untuk mengonfigurasi apakah cookie

yang terkait dengan permintaan HTTP harus dikirimkan bersamaan dengan permintaan lintas
situs atau tidak. Atribut ini memiliki tiga nilai: "None", "Lax", dan "Strict".
● "None" memungkinkan cookie dikirim dalam permintaan lintas situs jika permintaan
berasal dari domain yang sama dengan domain yang menyediakan cookie.
● "Lax" membatasi pengiriman cookie dalam permintaan lintas situs hanya jika
permintaan berasal dari tautan luar (misalnya, melalui link eksternal).
● "Strict" mengharuskan cookie hanya dikirim dalam permintaan lintas situs jika
permintaan berasal dari domain yang menyediakan cookie.
package main
import (
"net/http"
)
func main() {
e := echo.New()
// Middleware untuk mengatur SameSite attribute pada cookie

req := c.Request()
cookie := new(http.Cookie)
cookie.Name = "exampleCookie"
cookie.Value = "exampleValue"
cookie.SameSite = http.SameSiteLaxMode // Ganti
dengan http.SameSiteNoneMode atau http.SameSiteStrictMode sesuai
kebutuhan
// Set cookie pada response

c.SetCookie(cookie)
return next(c)
}
})

})
e.Start(":8080")
}
Pada contoh di atas, middleware ditambahkan untuk mengonfigurasi cookie dengan atribut
SameSite. Cookie disetel dengan atribut SameSiteLaxMode sebagai contoh, tetapi kita dapat
menggantinya dengan SameSiteNoneMode atau SameSiteStrictMode sesuai kebutuhan aplikasi
kita.
Dengan mengintegrasikan atribut SameSite ini dalam cookie, kita dapat meningkatkan
keamanan aplikasi web back-end kita dengan mencegah serangan CSRF yang mungkin terjadi
melalui permintaan lintas situs yang tidak sah.
Double Submit Cookies approach

Double Submit Cookies adalah salah satu pendekatan yang digunakan untuk mencegah
Cross-Site Request Forgery (CSRF) dalam pengembangan aplikasi web back-end. CSRF
merupakan serangan keamanan di mana penyerang dapat mengeksekusi aksi tanpa izin dari
pengguna yang terautentikasi. Pendekatan ini menggunakan konsep token yang disematkan
dalam cookie dan dipasangkan dengan nilai yang sama dalam permintaan HTTP. Dengan cara
ini, server dapat memverifikasi apakah permintaan berasal dari pengguna yang sah.
Dalam pengembangan web dengan Go (Golang) dan Echo, implementasi Double Submit
Cookies dapat dilakukan dengan cara sebagai berikut:
Membuat Token dan Menetapkannya ke Cookie

package main
import (
"crypto/rand"
"encoding/base64"
"net/http"
)
func generateToken() (string, error) {

bytes := make([]byte, 32)
_, err := rand.Read(bytes)
if err != nil {
return "", err
}
return base64.StdEncoding.EncodeToString(bytes), nil
}
func main() {
e := echo.New()
// Middleware untuk meng-handle CSRF dengan Double Submit

Cookies
CookieName: "csrf_cookie",
}))

// Membuat token dan menetapkannya ke cookie
token, err := generateToken()
if err != nil {
return err
}
c.SetCookie(&http.Cookie{
Name: "csrf_cookie",
Value: token,
})
// Mengirimkan token ke template atau respon JSON, sesuai

kebutuhan
return c.Render(http.StatusOK, "index",
map[string]interface{}{
"csrf_token": token,
})
})
// Memeriksa apakah token dalam cookie sesuai dengan
token dalam permintaan
if err := middleware.ValidateCSRF(c); err != nil {
return echo.NewHTTPError(http.StatusForbidden,
"Invalid CSRF token")
}
// Logika pengolahan data dari permintaan POST
return c.String(http.StatusOK, "Data berhasil disubmit")

})
e.Start(":8080")
}
Dalam contoh kode di atas, kita menggunakan Echo framework dengan middleware CSRF yang
disediakan. Token CSRF dihasilkan secara acak dan disematkan dalam cookie yang dikirimkan
kepada klien. Saat pengguna membuat permintaan POST, token tersebut juga harus
dimasukkan dalam badan permintaan atau sebagai parameter untuk memverifikasi keaslian
permintaan.
Penting untuk dicatat bahwa pendekatan ini hanya salah satu dari banyak cara untuk mencegah
CSRF, dan implementasinya dapat disesuaikan dengan kebutuhan spesifik proyek kita.
Anti-CSRF tokens in form submissions

Anti-CSRF tokens adalah langkah kritis dalam mencegah serangan Cross-Site Request Forgery
(CSRF) pada aplikasi web back-end. CSRF terjadi ketika penyerang dapat memaksa pengguna
untuk melakukan aksi tertentu tanpa persetujuannya melalui permintaan yang tidak diinginkan
yang dilakukan oleh browser pengguna yang telah di-"tokenkan" sebelumnya. Salah satu metode
yang efektif untuk mencegah CSRF adalah dengan menggunakan token yang unik untuk setiap
permintaan.
Golang dan Echo, sebagai framework web yang ringan dan efisien, menyediakan cara yang
mudah untuk mengimplementasikan Anti-CSRF tokens. Di bawah ini adalah contoh
implementasi dengan menggunakan Echo:
CsrfToken Struct
CsrfToken adalah sebuah struct yang digunakan untuk menyimpan token CSRF. sync.Mutex
digunakan untuk mengunci akses ke data tokens agar dapat diakses secara aman oleh
goroutine. tokens adalah map yang digunakan untuk menyimpan token-token CSRF yang
sudah digenerate.
type CsrfToken struct {
sync.Mutex
tokens map[string]bool
}
GenerateToken Function
GenerateToken adalah sebuah method pada struct CsrfToken untuk membuat token CSRF
baru. Token dihasilkan dengan menggunakan timestamp UnixNano untuk memastikan
keunikan. Setelah token dibuat, method ini mengunci data tokens, menambahkan token ke
dalam map, dan mengembalikan token yang baru dibuat.
func (c *CsrfToken) GenerateToken() string {

c.Lock()
defer c.Unlock()
token := fmt.Sprintf("%d", time.Now().UnixNano())

c.tokens[token] = true
return token
}
ValidateToken Function
ValidateToken adalah method pada struct CsrfToken untuk memvalidasi token yang
diberikan. Method ini mengunci data tokens, memeriksa keberadaan token dalam map, dan
jika ditemukan, menghapusnya dan mengembalikan true. Jika token tidak valid, method ini
mengembalikan false
func (c *CsrfToken) ValidateToken(token string) bool {

c.Lock()
defer c.Unlock()
_, exists := c.tokens[token]
if exists {
delete(c.tokens, token)
return true
}
return false
}
showForm Handler
showForm adalah handler untuk menampilkan formulir. Token CSRF di-generate menggunakan
method GenerateToken dan kemudian disertakan dalam render template.
func showForm(c echo.Context) error {
token := csrfToken.GenerateToken()
return c.Render(http.StatusOK, "form", token)
}
submitForm Handler
submitForm adalah handler untuk menangani submit formulir. Token CSRF diambil dari nilai
formulir dan divalidasi menggunakan method ValidateToken. Jika validasi berhasil, tindakan
yang diinginkan dapat dilakukan, jika tidak, tanggapan Status Forbidden dikembalikan.
func submitForm(c echo.Context) error {

token := c.FormValue("csrf_token")
if csrfToken.ValidateToken(token) {
// Lakukan tindakan yang diinginkan setelah validasi token
berhasil
return c.String(http.StatusOK, "Form berhasil disubmit!")
}
// Tindakan yang harus diambil jika validasi token gagal
return c.String(http.StatusForbidden, "Token CSRF tidak
valid!")
}
Main Function
● main adalah fungsi utama.
● Membuat instance CsrfToken yang akan digunakan di seluruh aplikasi.
● Membuat instance dari Echo framework.
● Menggunakan middleware Echo untuk menangani proteksi CSRF dengan konfigurasi
TokenLookup yang menunjukkan di mana mencari token CSRF (dalam formulir dengan
nama csrf_token).
● Menetapkan route /form untuk menampilkan formulir dan /submit untuk menangani
submit formulir.
● Menjalankan server pada port 8080.
func main() {
csrfToken := &CsrfToken{tokens: make(map[string]bool)}
e := echo.New()
// Middleware Echo untuk menangani CSRF

}))
// Routes
e.GET("/form", showForm)
e.POST("/submit", submitForm)
// Start server
e.Start(":8080")
}
Pada contoh di atas, kita membuat CsrfToken struct untuk mengelola token CSRF.
GenerateToken digunakan untuk membuat token baru dan menyimpannya, sementara
ValidateToken memeriksa apakah token yang diberikan valid.
Pada route /form, kita menampilkan formulir dengan token CSRF yang di-generate dan
dikirimkan ke template HTML. Pada route /submit, kita memvalidasi token yang dikirimkan
bersamaan dengan formulir sebelum melakukan tindakan yang sesuai.
Penting untuk memastikan bahwa token CSRF hanya digunakan satu kali dan dihapus setelah
validasi berhasil untuk mencegah penggunaan ulang yang tidak sah. Dengan menggunakan
mekanisme ini, aplikasi web dapat lebih aman terhadap serangan CSRF.
Mengidentifikasi dan Menanggulangi CSRF Vulnerabilities

CSRF terjadi ketika seorang penyerang memaksa pengguna yang telah diautentikasi untuk
melakukan tindakan tertentu tanpa persetujuannya, dengan menyelinapkan permintaan yang
tidak diinginkan melalui peramban pengguna. Identifikasi dan penanganan CSRF vulnerabilities
menjadi krusial dalam menjaga keamanan aplikasi back-end.
Untuk mengidentifikasi CSRF vulnerabilities, pengembang perlu memahami karakteristik

serangan ini. Biasanya, CSRF terjadi ketika aplikasi web tidak memvalidasi sumber permintaan
dengan benar atau tidak menggunakan mekanisme perlindungan yang memadai, seperti token
anti-CSRF. Oleh karena itu, langkah pertama adalah melakukan audit pada kode sumber aplikasi
untuk memastikan bahwa setiap tindakan yang memengaruhi keadaan server harus diotentikasi
dan diotorisasi dengan benar.
Selanjutnya, untuk mencegah CSRF vulnerabilities, penerapan token anti-CSRF adalah praktik
umum. Token ini ditanamkan dalam formulir atau permintaan HTTP, dan kemudian diverifikasi
oleh server untuk memastikan bahwa permintaan berasal dari sumber yang sah. Penggunaan
token ini dapat memutuskan tautan antara tindakan yang dilakukan oleh pengguna dan otorisasi
server, sehingga menghambat upaya penyerangan CSRF.
Selain itu, penting juga untuk memperbarui kebijakan SameSite pada cookie, yang dapat
membantu melindungi dari serangan CSRF. SameSite dapat dikonfigurasi untuk membatasi
pengiriman cookie hanya ketika permintaan berasal dari situs yang sama, mengurangi risiko
tautan antar situs yang dapat dimanipulasi oleh penyerang.
Penggunaan header HTTP tambahan seperti "Origin" dan "Referer" juga dapat membantu dalam
mendeteksi potensi serangan CSRF, meskipun mereka tidak boleh diandalkan sepenuhnya
karena dapat dimanipulasi oleh penyerang. Penerapan langkah-langkah ini secara komprehensif
dapat meminimalkan risiko CSRF vulnerabilities, meningkatkan keamanan aplikasi web
back-end, dan melindungi data serta aksi pengguna dari potensi eksploitasi oleh pihak yang
tidak berwenang.
Dalam konteks web security aplikasi back-end dengan menggunakan Golang dan framework
Echo, berikut adalah contoh implementasi pencegahan CSRF dengan menggunakan token CSRF
Struct MyForm
Definisi struktur MyForm untuk menyimpan data formulir. Pada contoh ini, hanya ada satu field
yaitu CSRFToken
type MyForm struct {

CSRFToken string `json:"csrf_token" form:"csrf_token"
query:"csrf_token"`
// tambahkan field formulir lainnya sesuai kebutuhan
}
Middleware addCSRFToken
● Middleware addCSRFToken bertugas menambahkan token CSRF ke setiap formulir.
● Menghasilkan token CSRF baru dengan fungsi generateCSRFToken().
● Menyimpan token CSRF dalam cookie dengan menggunakan SetCookie.
● Menambahkan token CSRF ke context Echo.
func checkCSRFToken(next echo.HandlerFunc) echo.HandlerFunc {

// Mengambil token CSRF dari formulir atau header
permintaan
csrfToken := c.FormValue("csrf_token")
if csrfToken == "" {
csrfToken = c.Request().Header.Get("X-CSRF-Token")
}
// Mengambil token CSRF yang disimpan dalam cookie atau
sesi
expectedCSRFToken, err := c.Cookie("csrf_token")
if err != nil || csrfToken != expectedCSRFToken.Value {
}
return next(c)
}
}
Middleware checkCSRFToken
● Middleware checkCSRFToken bertugas memeriksa kecocokan token CSRF pada setiap
permintaan POST.
● Mengambil token CSRF dari formulir atau header permintaan.
● Mengambil token CSRF yang disimpan dalam cookie.
● Membandingkan token dari permintaan dengan token yang disimpan. Jika tidak cocok,
mengembalikan respons 403 Forbidden.
func checkCSRFToken(next echo.HandlerFunc) echo.HandlerFunc {

// Mengambil token CSRF dari formulir atau header
permintaan
csrfToken := c.FormValue("csrf_token")
if csrfToken == "" {
csrfToken = c.Request().Header.Get("X-CSRF-Token")
}
// Mengambil token CSRF yang disimpan dalam cookie atau
sesi
expectedCSRFToken, err := c.Cookie("csrf_token")
if err != nil || csrfToken != expectedCSRFToken.Value {
}
return next(c)
}
}
Fungsi generateCSRFToken
Fungsi generateCSRFToken harus diimplementasikan sesuai kebutuhan aplikasi untuk
menghasilkan token CSRF yang unik.
func generateCSRFToken() string {

// Implementasi logika pembuatan token CSRF sesuai kebutuhan
return "generated_csrf_token"
}
Handler handleForm
● Handler handleForm menangani permintaan formulir.
● Memeriksa keberadaan dan kecocokan token CSRF dengan memanggil
checkCSRFToken.
● Jika token CSRF valid, melanjutkan pemrosesan formulir sesuai kebutuhan.
func handleForm(c echo.Context) error {

// Memeriksa keberadaan dan kecocokan token CSRF
if err := checkCSRFToken(c); err != nil {
return err
}
// Proses formulir jika token CSRF valid
// Implementasikan logika pemrosesan formulir sesuai kebutuhan
return c.String(http.StatusOK, "Form processed successfully")
}
Inisialisasi Echo dan Middleware

● Fungsi main adalah fungsi utama yang akan dieksekusi pertama kali.
● Membuat instance Echo dengan echo.New().
● Menambahkan middleware addCSRFToken dan checkCSRFToken menggunakan
e.Use.
● Mendefinisikan route /form yang akan ditangani oleh handler handleForm.
● Menjalankan server Echo di port 8080 dengan e.Start(":8080")
func main() {
// Inisialisasi Echo framework
e := echo.New()
// Middleware untuk menambahkan token CSRF ke setiap formulir

e.Use(addCSRFToken)
// Middleware untuk memeriksa kecocokan token CSRF pada setiap

permintaan POST
e.Use(checkCSRFToken)
// Route untuk menangani permintaan formulir

e.POST("/form", handleForm)
// Menjalankan server Echo di port 8080

e.Start(":8080")
}
OWASP Security Risks
Duration: 75:00
Memahami Web Security dan OWASP

Memahami keamanan web, khususnya pada aplikasi back-end, menjadi semakin penting
mengingat tingginya kompleksitas dan risiko yang terkait dengan ekosistem digital. Organisasi
Keamanan Aplikasi Web Terbuka (OWASP) menyediakan pedoman dan kerangka kerja yang
komprehensif untuk membantu profesional keamanan dan pengembang memahami serta
mengatasi risiko keamanan web. OWASP Security Risks merupakan daftar yang merinci potensi
ancaman dan celah keamanan yang umumnya ditemukan dalam aplikasi web. Terdapat
beberapa risiko kritis yang perlu dipahami, antara lain Injections, Broken Authentication,
Sensitive Data Exposure, XML External Entities (XXE), Security Misconfigurations, dan banyak
lagi.
Salah satu aspek penting adalah pemahaman mendalam terhadap risiko Injection, yang
mencakup SQL injection, Command injection, dan XPath injection. Ini melibatkan eksekusi kode
yang tidak sah melalui input pengguna, yang dapat memungkinkan penyerang mengambil alih
kontrol atau mengakses data sensitif. Selain itu, risiko Broken Authentication menyoroti potensi
celah keamanan dalam manajemen otentikasi dan sesi pengguna, yang dapat dimanfaatkan
untuk akses ilegal.
Selanjutnya, OWASP menyoroti Sensitive Data Exposure, di mana informasi penting dapat
terungkap jika tidak ditangani dengan benar. XML External Entities (XXE) adalah risiko yang
terkait dengan pemrosesan dokumen XML yang dapat dimanfaatkan untuk serangan. Security
Misconfigurations, termasuk konfigurasi yang tidak aman pada server atau aplikasi, juga
merupakan risiko yang dapat menyebabkan kebocoran data atau kerentanan lainnya.
Melalui pemahaman mendalam terhadap risiko-risiko ini, praktisi keamanan dan pengembang
dapat mengimplementasikan langkah-langkah perlindungan yang efektif untuk memitigasi
ancaman dan menjaga keamanan aplikasi web. Pentingnya mematuhi panduan OWASP tidak
hanya meningkatkan ketahanan sistem, tetapi juga membantu mencegah kerugian data dan
memperkuat kepercayaan pengguna terhadap aplikasi dan layanan online.
OWASP Application Security Verification Standard
OWASP Application Security Verification Standard (ASVS) merupakan suatu pedoman yang
dikembangkan oleh Open Web Application Security Project (OWASP) untuk membantu
organisasi dalam mengukur tingkat keamanan aplikasi mereka. ASVS menyediakan serangkaian
kontrol keamanan yang dapat diterapkan pada aplikasi web untuk mengidentifikasi dan
mengatasi risiko keamanan. Dalam konteks risiko keamanan web aplikasi backend berbasis
Golang, ASVS menawarkan panduan yang komprehensif untuk memitigasi berbagai ancaman
keamanan yang mungkin timbul.
ASVS mencakup beberapa tingkat verifikasi keamanan, yang mencakup pengujian pada level
perancangan arsitektur, keamanan operasional, dan implementasi teknis. Untuk aplikasi web
backend yang menggunakan bahasa pemrograman Golang, ASVS dapat memberikan panduan
spesifik yang mencakup kontrol keamanan seperti manajemen sesi, pengelolaan akses,
pengelolaan penyimpanan data, dan enkripsi data yang dapat diaplikasikan dalam lingkungan
Golang.
Selain itu, ASVS juga membantu mengidentifikasi dan mengatasi risiko keamanan spesifik yang
terkait dengan bahaya keamanan web, termasuk masalah keamanan yang mungkin timbul
dalam pengembangan aplikasi backend dengan Golang. Beberapa risiko umum yang dicakup
oleh ASVS melibatkan proteksi terhadap serangan injeksi, manajemen keamanan sesi,
pengendalian akses, validasi data, dan perlindungan terhadap serangan yang melibatkan
manipulasi input dan output.
Dengan menerapkan ASVS, organisasi yang mengembangkan aplikasi web backend

menggunakan Golang dapat meningkatkan tingkat keamanan sistem mereka, mengurangi
potensi celah keamanan, dan melindungi data sensitif dari ancaman yang mungkin timbul.
Melibatkan ASVS dalam siklus pengembangan aplikasi dapat membantu membangun produk
yang lebih aman dan dapat diandalkan di lingkungan web yang terus berkembang.
Input Validation
Input validation adalah langkah kritis dalam mengamankan aplikasi web backend dari serangan
keamanan. OWASP (Open Web Application Security Project) menyediakan pedoman dan risiko
keamanan umum yang harus diatasi dalam pengembangan perangkat lunak. Dalam konteks
risiko keamanan OWASP, validasi input bertujuan untuk mencegah serangan seperti SQL
injection, Cross-Site Scripting (XSS), dan serangan terkait input lainnya.
Golang, dengan kerangka kerja web Echo, menyediakan alat yang kuat untuk
mengimplementasikan validasi input. Berikut adalah contoh komprehensif mengenai
bagaimana kita dapat melakukan validasi input pada aplikasi web Golang dengan menggunakan
Echo.
Pertama, kita akan menggunakan package github.com/go-playground/validator/v10 untuk

validasi input. Pastikan untuk menginstal package ini dengan menjalankan perintah:
go get -u github.com/go-playground/validator/v10
Setelah itu, mari buat struktur data untuk representasi objek input dan aturan validasinya:
package main
import (
"fmt"
"github.com/go-playground/validator/v10"
"net/http"
)
type User struct {

Username string `json:"username" validate:"required,min=3"`
Email string `json:"email" validate:"required,email"`
Password string `json:"password" validate:"required,min=8"`
}
var validate = validator.New()
func main() {
e := echo.New()
e.POST("/register", registerUser)
e.Start(":8080")
}
func registerUser(c echo.Context) error {

user := new(User)
if err := c.Bind(user); err != nil {
return c.JSON(http.StatusBadRequest,
map[string]string{"error": "Invalid request body"})
}
if err := validate.Struct(user); err != nil {

map[string]string{"error": fmt.Sprintf("Validation error: %s",
err.Error())})
}
// Lakukan operasi registrasi pengguna setelah validasi

berhasil
return c.JSON(http.StatusOK, map[string]string{"message":

"User registered successfully"})
}
Pada contoh di atas, kita membuat struktur data User yang memiliki aturan validasi untuk
setiap atributnya. Selanjutnya, kita menggunakan Echo untuk membuat endpoint /register
yang menerima permintaan POST untuk registrasi pengguna. Dalam fungsi registerUser,
kita menggunakan validator untuk memeriksa apakah data input sesuai dengan aturan yang
ditentukan.
Jika validasi gagal, kita mengembalikan tanggapan JSON dengan status kode 400 dan pesan
kesalahan validasi. Jika validasi berhasil, kita dapat melanjutkan untuk melakukan operasi
registrasi pengguna atau tindakan lainnya.
Dengan menerapkan praktik ini, kita dapat mengurangi risiko serangan terkait input dan
meningkatkan keamanan aplikasi web backend kita. Selain itu, pastikan juga untuk
mengamankan aplikasi dari risiko keamanan OWASP lainnya, seperti pengendalian sesi yang
lemah, proteksi terhadap serangan CSRF, dan enkripsi data sensitif.
Data Sanitization
Data sanitization adalah praktik penting dalam mengatasi risiko keamanan pada aplikasi web
back-end, khususnya dalam konteks keamanan yang diidentifikasi oleh Open Web Application
Security Project (OWASP). OWASP memberikan pedoman dan risiko keamanan yang umum
dihadapi oleh aplikasi web, dan salah satu risiko utama adalah Injection, yang dapat disusupi
oleh data yang tidak diproses dengan benar.
Pada aplikasi back-end, terutama yang dikembangkan dengan bahasa pemrograman Golang
dan menggunakan framework Echo, data sanitization dapat diimplementasikan dengan
memastikan bahwa data yang diterima dari pengguna atau sumber eksternal telah dibersihkan
secara menyeluruh sebelum digunakan dalam operasi yang bersifat eksekusi atau dapat
disusupi.
Data sanitization melibatkan pengolahan dan validasi data input agar tidak dapat dieksekusi
sebagai perintah yang tidak aman oleh sistem. Pada aplikasi web back-end, ini terutama
diperlukan untuk mencegah serangan SQL injection atau jenis serangan lainnya di mana
penyerang mencoba menyusupkan kode berbahaya ke dalam input.
Dalam konteks Golang dan Echo, penggunaan fungsi html.EscapeString dapat membantu
menghindari injeksi HTML yang tidak diinginkan. Selain itu, penggunaan parameterized queries
pada operasi database dapat mengurangi risiko SQL injection. Sebagai langkah tambahan,
validasi input dengan mengimplementasikan regulasi ekspresi reguler (regex) atau fungsi
kustom dapat membantu memastikan bahwa data yang diterima sesuai dengan format yang
diharapkan.
package main
import (
"database/sql"
"fmt"
"html"
"net/http"
)
type User struct {

ID int `json:"id"`
Name string `json:"name"`
}
func main() {
e := echo.New()
// Contoh endpoint untuk menerima input dari pengguna

e.POST("/adduser", func(c echo.Context) error {
user := new(User)
// Mengambil data input dari pengguna

return err
}
// Membersihkan data input dari karakter HTML yang

berpotensi berbahaya
user.Name = html.EscapeString(user.Name)
// Validasi tambahan dapat dilakukan di sini, misalnya

dengan regex
// Menyimpan data ke database dengan parameterized query

db, err := sql.Open("sqlite3", "test.db")
if err != nil {
return err
}
defer db.Close()
_, err = db.Exec("INSERT INTO users (name) VALUES (?)",
user.Name)
if err != nil {
return err
}
return c.JSON(http.StatusOK, user)

})
}
Dalam contoh di atas, input dari pengguna, dalam hal ini nama pengguna, dibersihkan
menggunakan html.EscapeString untuk menghindari injeksi HTML. Selain itu, data yang
dimasukkan ke dalam database dijalankan dengan parameterized query untuk mencegah SQL
injection.
Penting untuk dicatat bahwa metode validasi dan sanitasi yang diperlukan dapat bervariasi
tergantung pada kebutuhan aplikasi spesifik dan jenis data yang diolah. Selalu penting untuk
memahami risiko keamanan yang mungkin dan menerapkan tindakan yang sesuai.
Handling Sessions and Cookies

Handling sessions and cookies merupakan aspek krusial dalam mengatasi risiko keamanan
pada aplikasi web, terutama terkait dengan OWASP Security Risks. OWASP, atau Open Web
Application Security Project, menyediakan pedoman untuk mengamankan aplikasi web dari
berbagai ancaman keamanan.
Untuk mengatasi risiko keamanan terkait sesi dan cookie pada back-end aplikasi web
menggunakan Golang dan Echo, perlu dilakukan implementasi praktik keamanan yang ketat.
Dalam Golang, kita dapat menggunakan package-package seperti "github.com/labstack/echo"
untuk menangani HTTP requests dan responses, dan "github.com/gorilla/sessions" untuk
mengelola sesi.
Pertama-tama, kita perlu memastikan bahwa setiap permintaan ke server diotentikasi dan
diotorisasi. Ini dapat dicapai dengan menggunakan sistem manajemen sesi yang aman. Kode
sumber berikut menunjukkan cara menggunakan package "gorilla/sessions" untuk menangani
sesi:
package main
import (
"net/http"
"github.com/gorilla/sessions"
)
var store = sessions.NewCookieStore([]byte("secret-key"))
func main() {
e := echo.New()

// Mengambil sesi dari cookie
session, err := store.Get(c.Request(), "session-name")
if err != nil {
return err
}
// Contoh penggunaan sesi

if auth, ok := session.Values["authenticated"].(bool);
!ok || !auth {
// Pengguna tidak terotentikasi, arahkan ke halaman
login
return c.Redirect(http.StatusFound, "/login")
}
// Pengguna terotentikasi, lanjutkan ke halaman utama

return c.String(http.StatusOK, "Selamat datang di halaman
utama!")
})
e.GET("/login", func(c echo.Context) error {

// Mengatur nilai sesi setelah pengguna berhasil login
session, _ := store.Get(c.Request(), "session-name")
session.Values["authenticated"] = true
session.Save(c.Request(), c.Response())
// Redirect ke halaman utama setelah login berhasil

return c.Redirect(http.StatusFound, "/")
})
e.GET("/logout", func(c echo.Context) error {

// Menghapus sesi setelah pengguna logout
session, _ := store.Get(c.Request(), "session-name")
session.Values["authenticated"] = false
session.Save(c.Request(), c.Response())
// Redirect ke halaman login setelah logout berhasil

return c.Redirect(http.StatusFound, "/login")
})
e.Start(":8080")
}
Pada contoh di atas, kita menggunakan "gorilla/sessions" untuk menyimpan informasi sesi,
seperti status otentikasi pengguna. Setiap kali pengguna berhasil login atau logout, nilai sesi
diperbarui dan disimpan kembali. Hal ini membantu dalam mengelola otentikasi pengguna dan
mengurangi risiko terkait keamanan sesi dan cookie.
Penting untuk mencatat bahwa kode sumber ini hanya contoh implementasi dasar, dan praktik
keamanan tambahan seperti mengatur waktu kedaluwarsa sesi dan mengamankan cookie
dengan HTTPS juga seharusnya diterapkan dalam aplikasi produksi.
Secure File Handling and Uploading

File handling dan pengunggahan file (file uploading) merupakan aspek krusial dalam
pengembangan aplikasi web, namun juga potensial menjadi titik lemah yang dapat dieksploitasi
oleh serangan keamanan. Untuk mengatasi risiko keamanan yang terkait, Organisasi Keamanan
Aplikasi Web (OWASP) memberikan pedoman dan rekomendasi untuk memitigasi ancaman
keamanan. Dalam konteks Go (Golang) dan framework web Echo, ada beberapa langkah yang
dapat diambil untuk menjaga keamanan aplikasi backend saat menangani file.
Pertama-tama, kita perlu memastikan bahwa file yang diunggah melewati validasi dan filtrasi
yang ketat. Pastikan hanya tipe file yang diizinkan yang diterima dan tolak file berbahaya.
Berikut adalah contoh implementasi pengunggahan file dengan validasi di Golang
menggunakan Echo:
main Function
● main adalah fungsi utama yang akan dijalankan saat program dimulai.
● echo.New() membuat instansi dari Echo framework untuk menangani routing HTTP.
● e.POST("/upload", handleFileUpload) mendefinisikan endpoint /upload
yang akan menangani permintaan POST dan memanggil fungsi handleFileUpload.
● e.Start(":8080") memulai server HTTP di port 8080.
package main
import (
"fmt"
"mime/multipart"
"net/http"
"os"
"path/filepath"
"strings"
)
const maxFileSize = 5 << 20 // 5 MB
func main() {
e := echo.New()
e.POST("/upload", handleFileUpload)
e.Start(":8080")
}
handleFileUpload Function
● handleFileUpload adalah fungsi yang menangani permintaan upload file.
● c.MultipartForm() membaca data formulir multipart dari permintaan.
● Loop pertama memeriksa ukuran file untuk memastikan tidak melebihi batas
(maxFileSize).
● Loop kedua memproses dan menyimpan setiap file yang valid ke server menggunakan
fungsi saveFile.
● Mengembalikan tanggapan berhasil jika semuanya berjalan dengan lancar.
func handleFileUpload(c echo.Context) error {

form, err := c.MultipartForm()
if err != nil {
return c.String(http.StatusInternalServerError, "Error
reading form data")
}
for _, files := range form.File {

for _, file := range files {
if file.Size > maxFileSize {
return c.String(http.StatusBadRequest, "File size
exceeds the limit")
}
}
}
for _, files := range form.File {

for _, file := range files {
if !isValidFileType(file) {
return c.String(http.StatusBadRequest, "Invalid
file type")
}
if err := saveFile(file); err != nil {

return c.String(http.StatusInternalServerError,
"Error saving file")
}
}
}
return c.String(http.StatusOK, "File(s) uploaded successfully")

}
isValidFileType Function
● isValidFileType memeriksa apakah ekstensi file yang diupload termasuk dalam
daftar ekstensi yang diizinkan.
● Mengembalikan true jika ekstensi valid, false sebaliknya.
func isValidFileType(file *multipart.FileHeader) bool {

allowedExtensions := []string{".jpg", ".jpeg", ".png", ".gif"}
ext := strings.ToLower(filepath.Ext(file.Filename))
for _, allowedExt := range allowedExtensions {
if ext == allowedExt {
return true
}
}
return false
}
saveFile Function
● saveFile menyimpan file ke server dengan membuat salinan dari file yang diunggah ke
direktori "uploads".
● Fungsi ini juga menciptakan nama file yang unik untuk menghindari overwrite dan konflik
nama.
func saveFile(file *multipart.FileHeader) error {

src, err := file.Open()
if err != nil {
return err
}
defer src.Close()
dst, err := os.Create("uploads/" +

generateUniqueFileName(file.Filename))
if err != nil {
return err
}
defer dst.Close()
if _, err := io.Copy(dst, src); err != nil {

return err
}
return nil
}
generateUniqueFileName Function
generateUniqueFileName membuat nama file yang unik dengan menambahkan timestamp
saat ini ke nama file asli
func generateUniqueFileName(filename string) string {

return fmt.Sprintf("%d_%s", time.Now().Unix(), filename)
}
SSL/TLS
Duration: 75:00
Memahami SSL/TLS
SSL (Secure Socket Layer) dan TLS (Transport Layer Security) merupakan protokol keamanan
yang kritis dalam konteks keamanan web, terutama pada aplikasi back-end. Keduanya
bertanggung jawab untuk menyediakan lapisan keamanan pada komunikasi data antara klien
dan server, melindungi informasi sensitif seperti kata sandi, informasi kartu kredit, dan data
pribadi lainnya dari serangan pihak ketiga yang berpotensi merugikan. SSL, yang lebih tua, telah
digantikan oleh TLS, namun keduanya sering digunakan secara bersamaan.
Pada dasarnya, SSL/TLS bekerja dengan mengenkripsi data yang dikirim antara klien dan server
menggunakan algoritma enkripsi yang kuat. Proses enkripsi ini menjadikan data sulit dibaca
oleh pihak yang tidak berwenang, sehingga memberikan lapisan keamanan yang vital untuk
mencegah peretasan dan penyadapan data. Selain itu, SSL/TLS juga menggunakan sertifikat
digital untuk mengotentikasi identitas server dan, dalam beberapa kasus, klien. Sertifikat ini
dikeluarkan oleh otoritas sertifikasi terkemuka, memastikan bahwa klien dapat mempercayai
identitas server yang mereka hubungi.
Implementasi SSL/TLS pada aplikasi back-end melibatkan konfigurasi server untuk mendukung
protokol ini dan pemilihan parameter keamanan yang tepat, seperti algoritma kriptografi dan
panjang kunci. Penting untuk memahami konsep kriptografi modern dan kelemahan yang
mungkin ada agar dapat membuat konfigurasi yang optimal dan tahan terhadap serangan.
Secara keseluruhan, pemahaman yang komprehensif tentang SSL/TLS dalam konteks

keamanan aplikasi web back-end memegang peranan kunci dalam melindungi data sensitif,
membangun kepercayaan antara klien dan server, dan memberikan lapisan keamanan yang
esensial dalam lingkungan internet yang penuh dengan potensi ancaman.
Persiapan SSL/TLS dengan crypto/tls

Persiapan SSL/TLS pada aplikasi backend web menggunakan Golang dan Echo melibatkan
beberapa langkah kunci. SSL/TLS adalah protokol keamanan yang digunakan untuk
mengamankan komunikasi antara klien dan server. Dengan menggunakan package crypto/tls
pada Golang, kita dapat mengimplementasikan lapisan keamanan ini.
Pertama, kita perlu menghasilkan atau mendapatkan sertifikat SSL/TLS. Sertifikat ini dapat
diperoleh dari otoritas sertifikat terpercaya atau melalui alat seperti Let's Encrypt. Setelah
mendapatkan sertifikat, kita dapat menyimpannya sebagai file .pem.
package main
import (
"fmt"
"golang.org/x/crypto/acme/autocert"
"net/http"
"os"
)
func main() {
e := echo.New()
// Konfigurasi Autocert untuk penggunaan Let's Encrypt

(Opsional)
m := autocert.Manager{
Prompt: autocert.AcceptTOS,
HostPolicy: autocert.HostWhitelist("example.com"), //
Ganti dengan domain kita
Cache: autocert.DirCache("certs"), //
Direktori untuk menyimpan sertifikat
}
// Middleware untuk mengaktifkan HTTPS dengan sertifikat Let's

Encrypt (Opsional)
e.Pre(middleware.HTTPSRedirect())
// Middleware untuk recovery dari panic

e.Use(middleware.Recover())
// Middleware untuk logging

e.Use(middleware.Logger())
// Routing
return c.String(http.StatusOK, "Hello, secure world!")
})
// Port untuk HTTP

httpPort := os.Getenv("HTTP_PORT")
if httpPort == "" {
httpPort = "80"
}
// Port untuk HTTPS

httpsPort := os.Getenv("HTTPS_PORT")
if httpsPort == "" {
httpsPort = "443"
}
// Mulai server HTTPS

go func() {
if err := e.StartTLS(fmt.Sprintf(":%s", httpsPort),
m.CertFile, m.KeyFile); err != nil {
e.Logger.Fatal(err)
}
}()
// Mulai server HTTP

if err := e.Start(fmt.Sprintf(":%s", httpPort)); err != nil {
e.Logger.Fatal(err)
}
}
Dalam contoh ini, kita menggunakan Echo sebagai framework web Golang. Autocert dari
package golang.org/x/crypto/acme/autocert digunakan untuk otomatis memperoleh
sertifikat Let's Encrypt. Middleware dari Echo juga digunakan untuk menangani redirect ke
HTTPS, recovery dari panic, dan logging.
Pastikan untuk mengganti "example.com" dengan domain sesuai aplikasi kita. Juga,
sesuaikan variabel lingkungan HTTP_PORT dan HTTPS_PORT sesuai dengan preferensi kita.
Jika kita tidak ingin menggunakan Let's Encrypt, kita dapat menyediakan sertifikat manual
dengan mengganti bagian yang sesuai dalam kode.
Dengan mengimplementasikan langkah-langkah ini, aplikasi backend kita akan dapat

berkomunikasi melalui protokol HTTPS, meningkatkan keamanan dan privasi data yang
ditransfer antara klien dan server.
Middleware untuk SSL/TLS

Middleware pada SSL/TLS berperan penting dalam meningkatkan keamanan aplikasi web
back-end. SSL/TLS (Secure Sockets Layer/Transport Layer Security) adalah protokol keamanan
yang digunakan untuk melindungi data yang dikirimkan antara klien dan server. Middleware ini
dapat disematkan dalam aplikasi menggunakan bahasa pemrograman seperti Go (Golang) dan
framework web seperti Echo untuk memastikan implementasi SSL/TLS yang benar.
Dalam Go, kita dapat menggunakan package crypto/tls untuk menangani keamanan SSL/TLS.
Middleware khusus SSL/TLS dapat dibuat untuk menambahkan lapisan keamanan pada
aplikasi Echo.
Middleware SSL/TLS dalam konteks keamanan aplikasi web back-end bertujuan untuk
menjamin bahwa komunikasi antara klien dan server terenkripsi dengan aman. SSL/TLS
menggunakan teknologi kriptografi untuk melindungi data sensitif yang dikirimkan melalui
jaringan. Middleware ini memastikan bahwa setiap permintaan dan respons yang melewati
aplikasi web dienkripsi dan didekripsi menggunakan sertifikat digital.
Dalam pengembangan web dengan Go dan Echo, package crypto/tls digunakan untuk
menangani implementasi SSL/TLS. Middleware SSL/TLS dapat disematkan ke dalam aplikasi
Echo untuk memastikan bahwa setiap permintaan masuk dan keluar dienkripsi dengan benar.
Dengan menggunakan sertifikat SSL yang valid, kita dapat meningkatkan keamanan aplikasi
web dan melindungi data sensitif pengguna.
package main
import (
"crypto/tls"
"net/http"
)
func main() {
e := echo.New()
// Middleware SSL/TLS
tlsConfig := &tls.Config{
MinVersion: tls.VersionTLS12,
PreferServerCipherSuites: true,
CurvePreferences: []tls.CurveID{tls.CurveP521,
tls.CurveP384, tls.CurveP256},
}
e.Use(middleware.SecureWithConfig(middleware.DefaultSecureConfig))
e.Use(middleware.BodyLimit("2M"))
// Tambahkan Middleware SSL/TLS

e.Use(middleware.WrapMiddleware(func(next http.Handler)
http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r
*http.Request) {
w.Header().Set("Strict-Transport-Security",
"max-age=31536000; includeSubDomains")
next.ServeHTTP(w, r)
})
}))
// Routing
return c.String(http.StatusOK, "Hello, secure world!")
})
// Start server dengan TLS

e.Logger.Fatal(e.StartTLS(":443", "cert.pem", "key.pem"))
}
Kode di atas menunjukkan penggunaan middleware Echo untuk mengimplementasikan

SSL/TLS dengan Go. Middleware SSL/TLS diatur dengan konfigurasi TLS yang disediakan oleh
crypto/tls. Middleware ini menetapkan header HTTP "Strict-Transport-Security" untuk
memastikan bahwa klien akan selalu berkomunikasi melalui protokol HTTPS setelah pertama
kali terhubung. Ini adalah contoh konfigurasi dasar, dan sesuaikan sesuai kebutuhan keamanan
aplikasi kita.
Secure Headers
Secure Headers adalah praktik penggunaan header HTTP tertentu untuk meningkatkan
keamanan aplikasi web yang menggunakan protokol SSL/TLS. Penggunaan header ini
membantu melindungi aplikasi dari berbagai serangan, termasuk serangan injeksi kode dan
serangan terhadap keamanan peramban (browser). Pada aplikasi backend menggunakan
Golang dan Echo framework, kita dapat mengimplementasikan Secure Headers untuk
meningkatkan keamanan.
Secure Headers melibatkan penetapan header tertentu dalam respons HTTP untuk mengontrol
perilaku peramban web dan melindungi aplikasi dari berbagai serangan. Beberapa header yang
umumnya digunakan dalam konteks SSL/TLS untuk meningkatkan keamanan adalah:
1. Strict-Transport-Security (HSTS)
Header ini mengarahkan peramban untuk selalu menggunakan HTTPS, mencegah
serangan man-in-the-middle.
2. Content-Security-Policy (CSP)
Header ini mengontrol sumber daya yang dapat dimuat oleh peramban, membantu
mencegah serangan Cross-Site Scripting (XSS).
3. X-Content-Type-Options
Header ini mengontrol cara peramban menginterpretasi konten dan dapat membantu
mencegah serangan MIME sniffing.
4. X-Frame-Options
Header ini membantu melindungi aplikasi dari serangan clickjacking dengan mengontrol
cara halaman dapat dimuat dalam bingkai (frame)
package main
import (
"net/http"
)
func main() {
e := echo.New()
// Middleware untuk menetapkan header Secure Headers

e.Use(middleware.SecureWithConfig(middleware.SecureConfig{
// Strict-Transport-Security (HSTS)
HSTSMaxAge: 31536000, // Durasi dalam detik (1 tahun)
HSTSIncludeSubdomains: true,
HSTSPreload: true,
// Content-Security-Policy (CSP)
ContentSecurityPolicy: "default-src 'self'; script-src
'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src
'self' data:;",
// X-Content-Type-Options
ContentTypeNosniff: true,
// X-Frame-Options
FrameDeny: true,
}))
// Rute contoh
})
// Mulai server pada port 8080

e.Start(":8080")
}
Pada contoh kode di atas, middleware SecureWithConfig dari Echo digunakan untuk
menetapkan header Secure Headers. kita dapat menyesuaikan konfigurasi sesuai dengan
kebutuhan aplikasi kita. Dengan menerapkan Secure Headers ini, kita dapat meningkatkan
keamanan aplikasi backend Golang kita yang berjalan di atas Echo framework.
Handling Authentication
Pentingnya keamanan dalam aplikasi web back-end tidak dapat diabaikan, terutama ketika
menangani otentikasi menggunakan protokol SSL/TLS. SSL/TLS digunakan untuk mengenkripsi
komunikasi antara klien dan server, memastikan kerahasiaan dan integritas data. Golang,
dengan kerangka kerja Echo, menyediakan alat yang kuat untuk menangani otentikasi SSL/TLS.
Pertama, kita perlu membuat sertifikat SSL/TLS untuk digunakan oleh server. Dalam lingkungan
produksi, kita biasanya mendapatkan sertifikat dari otoritas sertifikat terpercaya (CA), tetapi
untuk tujuan pengembangan, kita dapat membuat sertifikat sendiri:
package main
import (
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/x509"
"crypto/x509/pkix"
"encoding/pem"
"fmt"
"os"
"time"
)
func generateCertificate() {
priv, err := ecdsa.GenerateKey(elliptic.P384(), rand.Reader)
if err != nil {
fmt.Println("Error generating private key:", err)
return
}
notBefore := time.Now()
notAfter := notBefore.Add(365 * 24 * time.Hour) // Valid for 1
year
serialNumber, err := rand.Int(rand.Reader,

new(big.Int).Lsh(big.NewInt(1), 128))
if err != nil {
fmt.Println("Error generating serial number:", err)
return
}
template := x509.Certificate{
SerialNumber: serialNumber,
Subject: pkix.Name{
Organization: []string{"Your Organization"},
},
NotBefore: notBefore,
NotAfter: notAfter,
KeyUsage: x509.KeyUsageKeyEncipherment |
x509.KeyUsageDigitalSignature,
ExtKeyUsage:
[]x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
BasicConstraintsValid: true,
}
certDER, err := x509.CreateCertificate(rand.Reader, &template,

&template, &priv.PublicKey, priv)
if err != nil {
fmt.Println("Error creating certificate:", err)
return
}
certFile, err := os.Create("server.crt")

if err != nil {
fmt.Println("Error creating cert file:", err)
return
}
defer certFile.Close()
pem.Encode(certFile, &pem.Block{Type: "CERTIFICATE", Bytes:

certDER})
keyFile, err := os.Create("server.key")

if err != nil {
fmt.Println("Error creating key file:", err)
return
}
defer keyFile.Close()
privBytes, err := x509.MarshalECPrivateKey(priv)

if err != nil {
fmt.Println("Error marshaling private key:", err)
return
}
pem.Encode(keyFile, &pem.Block{Type: "EC PRIVATE KEY", Bytes:
privBytes})
}
func main() {
generateCertificate()
}
Kode di atas menghasilkan file sertifikat (server.crt) dan kunci pribadi (server.key) yang
akan digunakan oleh server Echo.
Berikutnya, kita dapat menggunakan Echo untuk membuat server HTTP dengan dukungan
SSL/TLS:
package main
import (
"fmt"
"net/http"
)
func main() {
e := echo.New()
// Middleware untuk mengaktifkan SSL/TLS

e.Use(middleware.Secure())
// Route untuk pengujian otentikasi

return c.String(http.StatusOK, "Hello, SSL/TLS!")
})
// Menjalankan server dengan sertifikat SSL/TLS

err := e.StartTLS(":443", "server.crt", "server.key")
if err != nil {
}
}
Dalam contoh di atas, kita menggunakan middleware dari Echo seperti Recover, Logger,
Secure, dan CORS untuk meningkatkan keamanan dan fungsionalitas server. Kemudian, kita
mendefinisikan rute sederhana di / yang akan memberikan respons "Hello, SSL/TLS!".
StartTLS digunakan untuk memulai server dengan dukungan SSL/TLS, dengan parameter
pertama menentukan port (443 untuk HTTPS), dan parameter kedua dan ketiga adalah path ke
file sertifikat dan kunci pribadi yang sudah di-generate sebelumnya.
Setelah server berjalan, akses aplikasi melalui browser dengan https://localhost atau
menggunakan perangkat lunak pengujian API seperti Postman.
Dengan langkah-langkah ini, kita telah mengimplementasikan otentikasi SSL/TLS pada aplikasi
web back-end menggunakan Golang dan Echo, meningkatkan keamanan komunikasi antara
klien dan server. Pastikan untuk menyimpan file sertifikat dan kunci pribadi dengan aman dalam
lingkungan produksi dan selalu gunakan sertifikat yang diterbitkan oleh otoritas sertifikat
terpercaya untuk keamanan yang lebih baik.
Managing SSL/TLS Certificates

Mengatur SSL/TLS Certificates pada aplikasi back-end menggunakan Golang dan Echo
memastikan bahwa komunikasi antara klien dan server dilakukan secara aman. SSL/TLS
(Secure Sockets Layer/Transport Layer Security) merupakan protokol keamanan yang
mengenkripsi data yang dikirim antara klien dan server, mencegah serangan seperti
man-in-the-middle.
Pertama, pastikan kita memiliki certificate dan private key yang valid. kita bisa mendapatkan
SSL/TLS certificate dari penyedia sertifikat yang dapat diandalkan atau menggunakan certbot
untuk mendapatkan sertifikat Let's Encrypt secara gratis.
Selanjutnya, gunakan package-package Golang yang diperlukan, seperti

"github.com/labstack/echo" untuk framework Echo dan "golang.org/x/crypto/acme/autocert"
untuk mengelola otomatisasi sertifikat Let's Encrypt. Berikut adalah contoh kode untuk
mengonfigurasi SSL/TLS dengan Echo:
package main
import (
"fmt"
"net/http"
"golang.org/x/crypto/acme/autocert"
)
func main() {
e := echo.New()
// Mode pengembangan, sebaiknya nonaktifkan di lingkungan

produksi
e.Debug = true
// Konfigurasi autocert untuk otomatisasi sertifikat Let's

Encrypt
m := autocert.Manager{
Prompt: autocert.AcceptTOS,
HostPolicy: autocert.HostWhitelist("example.com"), //
Ganti dengan domain kita
Cache: autocert.DirCache("certs"), //
Direktori penyimpanan cache sertifikat
}
// Atur penggunaan otomatis sertifikat jika domain sesuai

dengan kebijakan HostPolicy
e.AutoTLSManager = &m
// Definisikan route dan handler

})
// Start server dengan TLS

go func() {
if err := e.StartTLS(":443", "", ""); err != nil {
e.Logger.Info(fmt.Sprintf("Shutting down the
server: %v", err))
}
}()
// Atur otomatis redirect dari HTTP ke HTTPS

go func() {
if err := http.ListenAndServe(":80", m.HTTPHandler(nil));
err != nil {
e.Logger.Info(fmt.Sprintf("Shutting down the HTTP
server: %v", err))
}
}()
// Tunggu sinyal untuk keluar

}
Pastikan untuk mengganti "example.com" dengan domain sesuai kebutuhan kita. Dengan
konfigurasi ini, server akan secara otomatis memperoleh sertifikat Let's Encrypt dan
mengonfigurasi otomatis redirect dari HTTP ke HTTPS.
Dengan langkah-langkah ini, aplikasi back-end kita sekarang diatur dengan SSL/TLS untuk
meningkatkan keamanan komunikasi data. Selalu perbarui kode kita sesuai dengan praktik
keamanan terbaik dan pastikan bahwa sertifikat kita tetap terkini.
HTTP Strict Transport Security (HSTS)

HTTP Strict Transport Security (HSTS) adalah sebuah kebijakan keamanan pada web yang
dirancang untuk melindungi pengguna dari serangan man-in-the-middle seperti SSL stripping.
Kebijakan ini memastikan bahwa komunikasi antara browser dan server hanya terjadi melalui
koneksi HTTPS yang aman. HSTS diimplementasikan dengan menyertakan header khusus
dalam respons HTTP dari server ke browser, memberitahu browser untuk selalu menggunakan
protokol HTTPS selama jangka waktu tertentu, yang disebut masa laku HSTS.
Pada aplikasi back-end dengan menggunakan Golang dan Echo framework, kita dapat
mengimplementasikan HSTS dengan menambahkan header HSTS ke respons HTTP. Berikut
adalah contoh implementasinya:
package main
import (
)
func main() {
e := echo.New()
// Middleware HSTS untuk mengaktifkan HTTP Strict Transport

Security
e.Use(middleware.HSTSSkipper(func(c echo.Context) bool {
// Tambahkan logika pengecualian HSTS jika diperlukan
return false
}))
// Set header HSTS dengan waktu maksimum 6 bulan (180 hari)

e.Use(middleware.HSTSWithConfig(middleware.HSTSConfig{
MaxAge: int(180 * 24 * 60 * 60), // detik
}))
// Routing dan logika aplikasi lainnya
return c.String(200, "Hello, HTTPS!")
})
// Jalankan server pada port 8080

e.Start(":8080")
}
Pada contoh di atas, kita menggunakan middleware HSTS dari Echo framework untuk
menambahkan header HSTS ke setiap respons. Perhatikan bahwa kita dapat menentukan
kondisi pengecualian dengan menggunakan HSTSSkipper jika ada kebutuhan untuk tidak
menerapkan HSTS pada beberapa route atau kondisi tertentu.
Selain itu, kita dapat menyesuaikan MaxAge sesuai kebutuhan aplikasi. Masa laku HSTS diukur
dalam detik, dan dalam contoh ini, kita mengatur waktu maksimum menjadi 180 hari.
Implementasi ini membantu memastikan bahwa komunikasi antara browser dan server selalu
menggunakan koneksi HTTPS, meningkatkan keamanan aplikasi web backend terhadap
serangan yang melibatkan perubahan protokol komunikasi.
Testing dan Debugging

Testing dan debugging certificates pada SSL/TLS adalah langkah krusial dalam memastikan
keamanan aplikasi web backend. Sertifikat SSL/TLS digunakan untuk mengamankan
komunikasi antara klien dan server, memastikan bahwa data yang ditransfer dienkripsi dan tidak
dapat diakses oleh pihak yang tidak sah. Dalam konteks pengembangan aplikasi backend
dengan menggunakan Golang dan Echo framework, ada beberapa langkah yang dapat diambil
untuk menguji dan men-debug sertifikat SSL/TLS.
Pertama, untuk menguji sertifikat SSL/TLS, kita dapat membuat server HTTPS sementara yang
menggunakan sertifikat palsu (self-signed certificate) untuk tujuan pengujian. Berikut adalah
contoh kode dalam bahasa pemrograman Golang menggunakan Echo framework:
package main
import (
"net/http"
)
func main() {
e := echo.New()
// Middleware untuk menangani SSL/TLS

e.Use(middleware.SecureWithConfig(middleware.DefaultSecureConfig))
// Routes
})
// Mulai server HTTPS

err := e.StartTLS(":443", "path/to/certificate.crt",
"path/to/private.key")
if err != nil {
e.Logger.Fatal(err)
}
}
Dalam kode di atas, StartTLS digunakan untuk memulai server Echo dengan dukungan
SSL/TLS. kita perlu mengganti "path/to/certificate.crt" dan "path/to/private.key" dengan lokasi
sertifikat dan kunci pribadi yang sesuai. Pastikan bahwa sertifikat tersebut self-signed dan
hanya digunakan untuk keperluan pengujian.
Ketika kita menjalankan aplikasi ini, kita dapat mengaksesnya melalui browser dengan
menggunakan protokol HTTPS dan mengonfirmasi bahwa sertifikat SSL/TLS berfungsi dengan
baik.
Selanjutnya, untuk debugging, kita dapat menggunakan alat seperti "openssl" untuk memeriksa
detail sertifikat, seperti masa berlaku, informasi subjek, dan lainnya. Contoh:
openssl x509 -in path/to/certificate.crt -text -noout
Ini akan menampilkan informasi rinci tentang sertifikat kita, yang dapat membantu dalam
men-debug masalah yang mungkin timbul.
Dengan menggunakan pendekatan ini, kita dapat menguji dan men-debug sertifikat SSL/TLS
dengan lebih efektif dalam lingkungan pengembangan aplikasi web backend menggunakan
Golang dan Echo framework.
bcrypt
Duration: 75:00
Memahami bcrypt
Keamanan aplikasi web menjadi aspek kritis dalam pengembangan perangkat lunak, terutama
di sisi back-end. Salah satu aspek penting dari keamanan adalah penyimpanan kata sandi
pengguna dengan aman. Bcrypt, singkatan dari Blowfish Crypt, merupakan algoritma
penghashing kata sandi yang dirancang khusus untuk keamanan tinggi. Penggunaan Bcrypt
pada aplikasi back-end menggunakan Golang dan Echo dapat memberikan lapisan keamanan
yang lebih kuat.
Golang, dengan kecepatan eksekusi yang tinggi dan dukungan konkurensi bawaan, merupakan
pilihan yang populer untuk pengembangan aplikasi back-end. Echo, sebagai framework web
ringan untuk Golang, memberikan cara yang efisien dan elegan untuk membangun aplikasi web.
Pertama, kita perlu menginstal package "golang.org/x/crypto/bcrypt" untuk menggunakan

fungsi-fungsi Bcrypt dalam kode Golang kita. Berikut adalah contoh penggunaannya:
package main
import (
"fmt"
"golang.org/x/crypto/bcrypt"
)
func main() {
// Contoh untuk menghash kata sandi
password := "sandiRahasia123"
hashedPassword, err :=
bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err != nil {
fmt.Println("Error hashing password:", err)
return
}
fmt.Println("Hashed Password:", string(hashedPassword))
// Contoh untuk memeriksa kecocokan kata sandi

inputPassword := "sandiRahasia123"
err = bcrypt.CompareHashAndPassword(hashedPassword,
[]byte(inputPassword))
if err == nil {
fmt.Println("Password cocok!")
} else {
fmt.Println("Password tidak cocok:", err)
}
}
Dalam contoh di atas, GenerateFromPassword digunakan untuk hashing kata sandi saat
mendaftarkan pengguna, dan CompareHashAndPassword digunakan untuk memeriksa
kecocokan kata sandi saat pengguna mencoba untuk masuk. Fungsi ini secara otomatis
menangani salting, proses tambahan yang memperkuat keamanan dengan menambahkan data
acak ke setiap kata sandi.
Implementasi Bcrypt membantu melindungi aplikasi dari serangan hash rainbow table dan brute
force, membuatnya menjadi pilihan yang andal untuk menyimpan dan memverifikasi kata sandi
di lingkungan back-end. Dengan menggunakan Golang dan Echo, pengembang dapat dengan
mudah mengintegrasikan keamanan ini ke dalam aplikasi web mereka.
Mengintegrasi bcrypt dengan User Authentication

Pentingnya keamanan dalam aplikasi web tidak dapat diabaikan, terutama ketika menangani
autentikasi pengguna. Dalam pengembangan aplikasi back-end dengan menggunakan bahasa
pemrograman Golang dan framework Echo, mengintegrasikan bcrypt menjadi langkah kritis
untuk melindungi kata sandi pengguna dari serangan hash cracking. Bcrypt adalah fungsi hash
yang dirancang khusus untuk penyimpanan kata sandi yang aman, dengan penggunaan salt dan
iterasi yang dapat diatur.
Pertama-tama, pastikan kita telah menginstal package golang.org/x/crypto/bcrypt

yang menyediakan implementasi bcrypt untuk Golang. Ini dapat dilakukan dengan
menggunakan perintah go get:
go get golang.org/x/crypto/bcrypt
Setelah berhasil menginstal, langkah pertama adalah menangani registrasi pengguna. Ketika
pengguna membuat akun baru, kata sandi yang dimasukkan harus di-hash menggunakan bcrypt
sebelum disimpan dalam database. Berikut adalah contoh kode untuk menangani proses
registrasi di dalam handler Echo:
package main
import (
"net/http"
)
type User struct {

Username string `json:"username"`
Password string `json:"password"`
}
func register(c echo.Context) error {

user := new(User)
return err
}
// Hashing password using bcrypt

bcrypt.GenerateFromPassword([]byte(user.Password),
bcrypt.DefaultCost)
if err != nil {
return err
}
// Simpan hashed password ke database

// (Pada implementasi nyata, gunakan database ORM atau
middleware yang sesuai)
return c.JSON(http.StatusCreated, "User registered

successfully")
}
func main() {
e := echo.New()
e.POST("/register", register)
e.Start(":8080")
}
Selanjutnya, pada proses otentikasi, ketika pengguna mencoba untuk login, kita harus
memverifikasi kata sandi yang dimasukkan dengan hash yang ada di database. Berikut adalah
contoh kode untuk menangani proses otentikasi:
func login(c echo.Context) error {

user := new(User)
return err
}
// Retrieve hashed password from the database based on the

username
// (Pada implementasi nyata, gunakan database ORM atau
middleware yang sesuai)
// Verifikasi kata sandi

err :=
bcrypt.CompareHashAndPassword([]byte(hashedPasswordFromDatabase),
[]byte(user.Password))
if err != nil {
return echo.ErrUnauthorized
}
return c.JSON(http.StatusOK, "Login successful")

}
func main() {
e := echo.New()
e.POST("/login", login)
e.Start(":8080")
}
Dengan mengintegrasikan bcrypt pada proses registrasi dan otentikasi, kita meningkatkan
keamanan aplikasi web kita, membuatnya lebih sulit bagi pihak yang tidak sah untuk
mengakses kata sandi pengguna. Pastikan juga untuk menyesuaikan implementasi ini sesuai
kebutuhan dan struktur proyek kita untuk mencapai keamanan yang optimal.
Salting untuk Additional Security

Salting adalah praktik keamanan kriptografi yang melibatkan penggunaan nilai acak yang
disertakan bersama dengan kata sandi pengguna sebelum dilakukan proses hashing. Tujuan
dari salting adalah untuk mengatasi masalah serangan rainbow table, di mana penyerang dapat
menggunakan tabel hash pra-dihitung untuk dengan cepat memecahkan kata sandi yang
di-hash. Salah satu algoritma hashing yang umum digunakan untuk keamanan kata sandi
adalah bcrypt, dan ketika digunakan dengan benar, dapat memberikan tingkat keamanan yang
tinggi.
Penjelasan Konsep
Pada dasarnya, salting melibatkan pembuatan nilai acak yang disertakan bersama dengan kata
sandi sebelum di-hash. Nilai acak ini disebut "salt" dan harus unik untuk setiap pengguna. Salt
kemudian digabungkan dengan kata sandi pengguna sebelum menjalankan fungsi hashing.
Hasil akhir dari proses ini adalah nilai hash yang aman.
Implementasi dengan Golang dan Echo

Pertama-tama, pastikan kita memiliki package Echo dan bcrypt diinstal. kita dapat
menginstalnya dengan menggunakan perintah berikut
go get -u github.com/labstack/echo/v4
go get -u golang.org/x/crypto/bcrypt
Contoh Kode
package main
import (
"fmt"
"net/http"
)
type User struct {

}
func main() {
e := echo.New()
// Contoh API endpoint untuk mendaftarkan pengguna dengan kata

sandi yang di-salt
e.Start(":8080")
}

// Mendapatkan data pengguna dari permintaan
user := new(User)
return c.String(http.StatusBadRequest, "Invalid request
payload")
}
// Menghasilkan salt yang unik
salt, err := bcrypt.GenerateSalt(10)
if err != nil {
generating salt")
}
// Menggabungkan kata sandi pengguna dengan salt

hashedPassword, err := bcrypt.HashPassword(user.Password,
salt)
if err != nil {
hashing password")
}
// Simpan username, hashedPassword, dan salt di database atau

penyimpanan lainnya
return c.String(http.StatusOK, "User registered successfully")

}
Dalam contoh di atas, bcrypt.GenerateSalt digunakan untuk membuat salt, dan

bcrypt.HashPassword digunakan untuk menggabungkan kata sandi pengguna dengan salt
dan menghasilkan hash. Selanjutnya, kita dapat menyimpan informasi pengguna, termasuk
username, hashedPassword, dan salt, di database atau penyimpanan data lainnya.
Password Policy dan Best Practices

Password policy merupakan sejumlah pedoman keamanan yang ditetapkan untuk mengelola
kata sandi pengguna dengan tujuan meningkatkan keamanan aplikasi web. Implementasi
password policy yang baik sangat penting dalam melindungi data sensitif dan mengurangi
risiko serangan keamanan. Salah satu teknik yang sering digunakan dalam menyimpan kata
sandi adalah bcrypt, yang merupakan fungsi hash khusus dirancang untuk keamanan kata
sandi.
Pertama-tama, pastikan kebijakan kata sandi mematuhi standar keamanan, seperti memerlukan
panjang kata sandi yang cukup, mengharuskan pengguna untuk menggunakan kombinasi huruf
besar, huruf kecil, angka, dan karakter khusus. Selain itu, lakukan verifikasi kekuatan kata sandi
dan instruksikan pengguna untuk membuat kata sandi yang unik.
main Function
● Fungsi utama yang memulai server Echo.
● Middleware ditambahkan untuk menetapkan header keamanan dan CORS.
● Endpoint /register dibuat untuk menangani registrasi pengguna.
package main
import (
"fmt"
"net/http"
)
type User struct {

}
func main() {
e := echo.New()
// Middleware untuk menambahkan keamanan terkait header dan

CORS
c.Response().Header().Set(echo.HeaderServer,
"SecureServer")
c.Response().Header().Set("X-Frame-Options",
"DENY")
c.Response().Header().Set("X-Content-Type-Options",
"nosniff")
c.Response().Header().Set("Strict-Transport-Security",
"max-age=63072000; includeSubDomains")
c.Response().Header().Set("X-XSS-Protection", "1;
mode=block")
return next(c)
}
})
// Endpoint untuk registrasi pengguna

e.Start(":8080")
}
registerUser Function
● Fungsi yang menangani registrasi pengguna.
● Menerima data pengguna dari permintaan POST, memeriksa kekuatan kata sandi, dan
melakukan hashing menggunakan bcrypt.
● Simulasi penyimpanan informasi pengguna ke database.

user := new(User)
map[string]string{"error": "Invalid request payload"})
}
// Memeriksa kekuatan kata sandi

if !isStrongPassword(user.Password) {
map[string]string{"error": "Password is too weak"})
}
// Hashing kata sandi dengan bcrypt

bcrypt.GenerateFromPassword([]byte(user.Password),
bcrypt.DefaultCost)
if err != nil {
return c.JSON(http.StatusInternalServerError,
map[string]string{"error": "Internal Server Error"})
}
// Simpan informasi pengguna, termasuk hashedPassword, ke

database atau penyimpanan data yang sesuai
return c.JSON(http.StatusOK, map[string]string{"message": "User

registered successfully"})
}
isStrongPassword Function
● Fungsi yang memeriksa kekuatan kata sandi berdasarkan kebijakan tertentu.
● Contoh kebijakan sederhana: panjang minimal 8 karakter, setidaknya satu huruf besar,
satu huruf kecil, dan satu angka.
func isStrongPassword(password string) bool {

return len(password) >= 8 &&
containsUppercase(password) &&
containsLowercase(password) &&
containsDigit(password)
}
containsUppercase, containsLowercase, dan containsDigit Functions

func containsUppercase(s string) bool {
for _, char := range s {
if 'A' <= char && char <= 'Z' {
return true
}
}
return false
}
func containsLowercase(s string) bool {

if 'a' <= char && char <= 'z' {
return true
}
}
return false
}
func containsDigit(s string) bool {

if '0' <= char && char <= '9' {
return true
}
}
return false
}
Secara keseluruhan, kode ini menciptakan server sederhana menggunakan Echo framework,
menangani registrasi pengguna, memeriksa kekuatan kata sandi, dan melakukan hashing
menggunakan bcrypt sebelum menyimpannya ke database (simulasi). Fungsi-fungsi bantu
digunakan untuk memeriksa kekuatan kata sandi berdasarkan kebijakan tertentu.

Modul 11 Web Security

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Modul 11 Web Security

Uploaded by

Copyright:

Available Formats

Modul 11 - Web Security

Last Updated: 2023-09-13

Materi Teks Interaktif

Kuis Interaktif dan Latihan

Proyek dan Tugas Praktis

Tipe-Tipe Resiko Keamanan pada Aplikasi Back-End

// Membuat pernyataan SQL tanpa validasi atau penyaringan

// Mengambil data dari hasil query

// Menampilkan informasi pengguna

Authentication and Authorization Issues

// Contoh fungsi authentication sederhana

// Contoh middleware authorization sederhana

// Fungsi bantu untuk memeriksa hak akses pengguna

// Ganti "cert.pem" dan "key.pem" dengan sertifikat dan kunci

// Contoh penggunaan parameterized query

_, err = db.Exec("INSERT INTO users (username, password)

fmt.Println("User added successfully.")

Cross-Origin Resource Sharing (CORS)

// Middleware untuk menangani CORS

Cross-Site Request Forgery (CSRF)

// Middleware for CSRF protection

e.POST("/process", func(c echo.Context) error {

// Start the server

// Koneksi ke database (contoh dengan SQLite)

var result string

return c.String(http.StatusOK, result)

Denial of Service (DoS) and Distributed Denial of Service (DDoS)

// Set up rate limiting middleware

// Define your routes and handlers

// Start the server

Statelessness dan Implikasi HTTP

// Endpoint untuk HTTP

// Endpoint untuk HTTPS

// Mulai server HTTP pada port 8080

// Mulai server HTTPS pada port 8443 dengan sertifikat TLS

Faedah Kepentingan Komunikasi dengan HTTPS

// Menjalankan server HTTPS

Dalam contoh kode di atas, middleware HTTPSRedirect digunakan untuk memaksa

// Middleware untuk mengaktifkan HTTPS

// Middleware untuk menangani HTTPS

e.GET("/", func(c echo.Context) error {

// Menjalankan server dengan HTTPS

Keunggulan HTTPS dan Manfaat HTTP/2

Sehingga, manfaat HTTP/2 memberikan peningkatan performa yang signifikan dibandingkan

// Middleware untuk mengaktifkan HTTPS

// Handler untuk route "/"

// Menjalankan server pada port 443 dengan sertifikat TLS

Contoh kode sederhana untuk menggunakan HTTP/2 dengan Echo:

// Handler untuk route "/"

// Menjalankan server dengan HTTP/2

Memahami Cross-Origin Resource Sharing (CORS)

Troubleshooting CORS Issues

Penyelesaian untuk permasalahan CORS melibatkan konfigurasi server back-end untuk

Selain header "Access-Control-Allow-Origin", ada juga header lain seperti

// Konfigurasi middleware CORS

// Registrasi route atau endpoint lainnya di sini

// Middleware untuk menambahkan header yang mematuhi

// Route untuk Simple Request

// Route untuk Complex Request (contoh metode PUT)

// Mulai server Echo pada port 8080

// Middleware CORS untuk menangani Preflight Requests

// Mulai server Echo

Implementasi API Security CORS dengan Echo