Halo, saya Nanda

• React Native Developer
• Pernah nulis soal security & API di Medium (@naandalist)

medium.com/@naandalist · mobiledev.id/@nanda

Disclaimer

• Materi ini untuk belajar, debugging app sendiri, dan memperkuat keamanan.
• Praktikkan ke app milik sendiri, atau yang kamu punya izin.
• Cek Terms of Service & aturan hukum (mis. UU ITE, UU PDP) sebelum menyentuh app orang lain.
• Data pribadi orang lain = jangan disentuh.

Perjalanan kita hari ini

Scraping = mengambil data dari sebuah sistem lewat jalur yang dipakai manusia/app, bukan lewat jalur resmi untuk developer.

Tiga level scraping web

Level 3 adalah jembatan ke mobile: jangan scrape tampilannya, ambil datanya.

Contoh: parse HTML

import * as cheerio from 'cheerio';

const html = await (await fetch('https://toko-contoh.id/produk')).text();
const $ = cheerio.load(html);

const products = $('.product-card').map((_, el) => ({
  name:  $(el).find('.title').text().trim(),
  price: $(el).find('.price').text().replace(/\D/g, ''),
})).get();

console.log(products);
					

Gampang… sampai desainer mengganti .product-card

Kenapa web relatif mudah?

• DevTools ada di setiap browser, Network tab langsung kelihatan
• Kode frontend (JS) terkirim ke client dan bisa dibaca
• Browser percaya CA sistem, tidak ada certificate pinning
• Request bisa di-copy as cURL dalam satu klik

Di mobile, hampir semua kemudahan ini hilang.

Setiap app di HP kamu sedang ngobrol dengan server.
Di balik layar ada API yang mengirim data mentah, app cuma menggambarnya.

Tantangan di mobile

Tapi… API mobile sering lebih "ramah"

• Response-nya JSON bersih, tidak perlu parse HTML
• Endpoint versi lama sering masih hidup demi backward compatibility
• Asumsi "ini kan cuma dipanggil app kita" → validasi & rate limit lebih longgar
• API key / secret kadang tertanam di binary

Sebagai pemilik app: asumsi "hanya app kita yang memanggil" itu yang paling berbahaya.

Lima pendekatan, dari mudah ke sulit

Menonton obrolan app dan server

1. Jalankan proxy di laptop, arahkan Wi-Fi HP/emulator ke sana
2. Pasang CA sertifikat proxy di device (emulator / device test)
3. Buka layar yang datanya kamu mau → lihat request yang muncul

Untuk app sendiri: build debug dengan network_security_config yang trust user CA, tanpa perlu bypass apa pun.

Anatomi sebuah request

GET /v2/products?category=12&page=1&limit=20 HTTP/2
Host: api.example-app.com
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...
X-App-Version: 5.12.0
X-Device-Id: 8f3c2a91-...
X-Signature: 9b1e0c...            <-- dinamis? dihitung dari apa?
User-Agent: okhttp/4.12.0

{ "data": [ ... ], "meta": { "next_cursor": "eyJpZCI6..." } }
					

• Endpoint di balik layar mana? Cocokkan dengan aksi di UI.
• Header mana yang wajib? Hapus satu per satu sampai request gagal.
• Token dari mana & kapan expired? Cari request login / refresh.

Rebuild request di luar app

const headers = {
  Authorization: `Bearer ${TOKEN}`,
  'X-App-Version': '5.12.0',
  'User-Agent': 'okhttp/4.12.0',
};

const res = await fetch(
  'https://api.example-app.com/v2/products?category=12&page=1',
  { headers },
);
console.log(await res.json());
					

Kalau ini berhasil… server tidak bisa membedakan script ini dengan app asli.

Pagination & response yang "messy"

let cursor = null;
const all = [];

do {
  const url = new URL(BASE + '/v2/products');
  if (cursor) url.searchParams.set('cursor', cursor);

  const { data, meta } =
    await (await fetch(url, { headers })).json();

  all.push(...data);
  cursor = meta?.next_cursor;
  await sleep(1000); // sopan ke server
} while (cursor);
						

Membongkar APK

Kalau static tidak cukup

Kapan sulit, dan kapan tidak worth it?

Apa ruginya kalau API kita "dicuri"?

Auth yang benar ≠ client yang sah

• Backend sudah cek token, authorization, validasi input
• Tapi token itu milik akun yang sah, scraper cukup login seperti user biasa
• Server tahu SIAPA usernya, tapi tidak tahu DARI MANA request-nya

Request yang "valid" secara auth tetap bisa merugikan kalau tidak datang dari app kita.

Ketika dashboard "Tidak Sync"

Angka di atas ilustrasi. Kebalikannya juga terjadi: bot yang menembak endpoint tracker → DAU palsu.

Berlapis, bukan satu tembok

Static API key = golden ticket abadi

• "Kan sudah HTTPS?" Belum cukup: HTTPS bisa dibuka di device yang dipasangi rogue root CA (persis teknik #2 tadi)
• Key statis tidak pernah expired → sekali bocor, bocor selamanya
• Butuh solusi yang ringan: tanpa database, cocok untuk proxy/microservice

Time-based signature dengan HMAC

Jangan kirim secret-nya. Kirim bukti bahwa kamu tahu secret-nya, dan bukti itu kedaluwarsa dalam hitungan detik.

signature = HMAC_SHA256( secret,  epochMs + requestUrl + bodyString )
					

Bagaimana client & server bekerja

Disadap lalu di-replay? Cepat basi.

Bandingkan dengan static key tadi: copy yang sama hanya berguna beberapa detik, dan request yang diubah langsung ditolak.

Menandatangani request

import { createHmac } from 'react-native-quick-crypto';
const SECRET = getSecretFromNative(); // jangan hardcode string polos di JS

export async function signedFetch(url: string, body?: object) {
  const epoch = Date.now().toString();
  const bodyStr = body ? JSON.stringify(body) : '';

  const signature = createHmac('sha256', SECRET)
    .update(`${epoch}${url}${bodyStr}`)
    .digest('hex');

  return fetch(url, {
    method: body ? 'POST' : 'GET',
    headers: {
      'Content-Type': 'application/json',
      'X-Auth-Epoch': epoch,
      'X-Auth-Signature': signature,
    },
    body: body ? bodyStr : undefined,
  });
}
					

Memverifikasi signature

const SKEW_MS = 60_000;

app.use('/api/protected/*', async (c, next) => {
  const epoch = Number(c.req.header('X-Auth-Epoch'));
  const sig = c.req.header('X-Auth-Signature') ?? '';
  if (!epoch || Math.abs(Date.now() - epoch) > SKEW_MS)
    return c.json({ error: 'Request expired' }, 401);

  const body = await c.req.raw.clone().text();
  const expected = createHmac('sha256', SECRET)
    .update(`${epoch}${c.req.url}${body}`)
    .digest('hex');

  if (sig.length !== expected.length ||
      !timingSafeEqual(Buffer.from(sig), Buffer.from(expected)))
    return c.json({ error: 'Invalid signature' }, 401);

  await next(); // lolos → proxy ke API tujuan
});
					

Apa yang kita dapat, dan apa yang tidak

Hanya app terdaftar yang boleh akses?

Key dibatasi ke package name + SHA-1 sertifikat signing (iOS: bundle ID). App lain ditolak.

Kenapa script tadi bisa lolos?

• App mengirim header X-Android-Package & X-Android-Cert (iOS: X-Ios-Bundle-Identifier)
• Nilainya bukan rahasia: package ada di manifest, SHA-1 terbaca lewat apksigner verify --print-certs
• Server hanya mencocokkan string, jadi siapa pun yang menyalin header ikut lolos

Menyebut fingerprint ≠ membuktikan fingerprint.

App attestation: bukti dari Google & Apple

Play Integrity (Android) · App Attest (iOS) · atau Firebase App Check yang membungkus keduanya.

Ikat token ke request, verifikasi di server

// App (pseudo-code): token diikat ke request ini
const requestHash = sha256(`${epoch}${url}${body}`);
const token = await integrity.requestToken({ requestHash });

// Server: decode lewat Google, lalu cek isinya
const { tokenPayloadExternal: v } =
  await playintegrity.v1.decodeIntegrityToken({
    packageName: 'com.contoh.app',
    requestBody: { integrityToken: token },
  });

const valid =
  v.requestDetails.requestHash === sha256(`${epoch}${url}${body}`) &&
  Date.now() - Number(v.requestDetails.timestampMillis) < 60_000 &&
  v.appIntegrity.appRecognitionVerdict === 'PLAY_RECOGNIZED' &&
  v.appIntegrity.certificateSha256Digest.includes(OUR_CERT_SHA256) &&
  v.deviceIntegrity.deviceRecognitionVerdict?.includes('MEETS_DEVICE_INTEGRITY');
					

Sebelum dipasang di production

Membuatnya lebih sulit lagi

Yang perlu dibawa pulang

1. App mobile hanya menggambar data, API-nya yang jadi target.
2. Semua yang ada di client bisa dibaca dan diubah.
3. Backend yang "secure" belum tentu aman dari kerugian bisnis; analytics pun bisa kacau.
4. Security itu soal menaikkan biaya penyerang, berlapis-lapis.
5. Time-based signature: murah, stateless, dan langsung mematikan replay sederhana.
6. Mau API hanya untuk app terdaftar? Pakai attestation, bukan sekadar header fingerprint.