https://ctflearn.com/challenge/962

Learn apktool and the altenatif by web apps

The main idea of finding the flag is Bruteforce the strings.

Step-1:

Downloaded the BasicAndroidRE1.apk

Step-2:

Googled on how to reverse engineer APK files, found references to use apktool or http://www.javadecompilers.com/apk to extract resources from an APK file

Step-3:

Attempted to decode tha APK file using

apktool d BasicAndroidRE1.apk

or just simply upload the BasicAndroidRE1.apk to http://www.javadecompilers.com/apk

Step-4:

<?xml version="1.0" encoding="utf-8" standalone="no"?><manifest xmlns:android="http://schemas.android.com/apk/res/android" android:compileSdkVersion="29" android:compileSdkVe>
    <application android:allowBackup="true" android:appComponentFactory="androidx.core.app.CoreComponentFactory" android:icon="@mipmap/ic_launcher" android:label="@string/app>
        <activity android:name="com.example.secondapp.MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
    </application>
</manifest>

Manually inspected the AndroidManifest.xml file in BasicAndroidRE1 directory and found reference to com.example.secondapp.MainActivity which appears to be a Java class file

or it look like this if you using the web tool

Step-5:

Manually located the MainActivity MainActivity.smali file under BasicAndroidRE1\smali\com\example\secondapp,

.class public Lcom/example/secondapp/MainActivity;
.super Landroidx/appcompat/app/AppCompatActivity;
.source "MainActivity.java"


# direct methods
.method public constructor <init>()V
    .locals 0

    .line 12
    invoke-direct {p0}, Landroidx/appcompat/app/AppCompatActivity;-><init>()V

    return-void
.end method


# virtual methods
.method protected onCreate(Landroid/os/Bundle;)V
    .locals 0

    .line 16
    invoke-super {p0, p1}, Landroidx/appcompat/app/AppCompatActivity;->onCreate(Landroid/os/Bundle;)V

    const p1, 0x7f09001c

    .line 17
    invoke-virtual {p0, p1}, Lcom/example/secondapp/MainActivity;->setContentView(I)V

    return-void
.end method

.method public submitPassword(Landroid/view/View;)V
    .locals 3

    const p1, 0x7f070037

    .line 21
    invoke-virtual {p0, p1}, Lcom/example/secondapp/MainActivity;->findViewById(I)Landroid/view/View;

    move-result-object p1

    check-cast p1, Landroid/widget/EditText;

    .line 22
    invoke-virtual {p1}, Landroid/widget/EditText;->getText()Landroid/text/Editable;

    move-result-object v0

noticed that number of const_string references which appeared to be consistent with CTFlearn flag format, performed

grep const-string MainActivity.smali

if using the web tool look for MainActivity.java file. I got it at location: sources/com/example/secondapp/MainActivity.java

MainActivity.java had this:

package com.example.secondapp;

import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import org.apache.commons.codec.digest.DigestUtils;

public class MainActivity extends AppCompatActivity {
    /* access modifiers changed from: protected */
    public void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        setContentView((int) C0272R.layout.activity_main);
    }

    public void submitPassword(View view) {
        EditText editText = (EditText) findViewById(C0272R.C0274id.editText2);
        if (DigestUtils.md5Hex(editText.getText().toString()).equalsIgnoreCase("b74dec4f39d35b6a2e6c48e637c8aedb")) {
            TextView textView = (TextView) findViewById(C0272R.C0274id.textView);
            StringBuilder sb = new StringBuilder();
            sb.append("Success! CTFlearn{");
            sb.append(editText.getText().toString());
            sb.append("_is_not_secure!}");
            textView.setText(sb.toString());
        }
    }
}

Step-6:

This flag has 3 parts. We basically need to reverse the given hash.

b74dec4f39d35b6a2e6c48e637c8aedb

Step-7:

Try decrypt the string at: https://www.md5online.org/md5-decrypt.html

Step-8:

Finally, the flag becomes: CTFlearn{Spring2019_is_not_secure!}

Summary

Summary of Reverse Engineering APK Challenge:
In this Capture The Flag (CTF) challenge, the objective was to reverse engineer an APK file called "BasicAndroidRE1" to find the flag. The challenge involved the use of tools like apktool or an online APK decompiler to extract resources from the APK file.
The first step was to download the APK file and then decode it using apktool or by uploading it to an online decompiler. The AndroidManifest.xml file and MainActivity.smali file were inspected to gather information about the application's structure and functionality.
The MainActivity.smali file revealed the presence of a method called "submitPassword" that performed a comparison of an MD5 hash with a hardcoded value. The hash value was extracted from the code, and an online MD5 decryption tool was used to reverse the hash and obtain the flag.
After decrypting the hash, the flag was revealed as "CTFlearn{Spring2019_is_not_secure!}".
This challenge showcased the process of reverse engineering an APK file, examining the application's code, and using cryptographic techniques to uncover hidden information.

Lessons to be learned from completing this ctf challenge:

Dari penyelesaian tantangan CTF ini, terdapat beberapa pelajaran yang dapat dipetik:

1. Pengetahuan tentang Reverse Engineering: Melalui proses ini, pelaku CTF perlu memahami cara membalikkan atau menganalisis kode aplikasi untuk mencari informasi atau celah keamanan. Dalam kasus ini, APK file dipecah menggunakan tools seperti apktool atau dekompilator web untuk mendapatkan kode sumber aplikasi.

2. Pemahaman AndroidManifest.xml: File ini mengandung informasi tentang komponen dan konfigurasi aplikasi Android. Dalam penyelesaian tantangan ini, penyelesaian mencermati file AndroidManifest.xml untuk mencari jejak komponen yang relevan dalam mencari flag.

3. Pemahaman tentang struktur Smali dan Java: Smali adalah bahasa yang digunakan dalam menggambarkan kode sumber dalam bentuk bytecode pada aplikasi Android. Dalam kasus ini, penyelesaian mencari file Smali (MainActivity.smali) dan Java (MainActivity.java) untuk memahami logika aplikasi dan menemukan bagian kode yang relevan untuk memecahkan flag.

4. Penggunaan Algoritma Hashing: Dalam tantangan ini, dilakukan decrypt string dengan menggunakan algoritma hash MD5 untuk mencocokkan hasil hash dengan flag yang diinginkan.

5. Pentingnya Penelitian dan Pemecahan Masalah: Penyelesaian tantangan ini melibatkan langkah-langkah yang meliputi pencarian referensi, analisis kode, penggunaan tool online, dan memecahkan masalah dengan kreativitas. Ini menunjukkan betapa pentingnya kemampuan penelitian dan pemecahan masalah dalam menghadapi tantangan CTF.

Dengan mempelajari dan mempraktikkan tantangan semacam ini, dapat meningkatkan pemahaman tentang keamanan aplikasi, analisis kode, dan pemecahan masalah yang relevan dalam konteks teknologi.

The lesson that can be learned from the message fragment contained in the flag that was obtained:

Dari kata-kata yang terdapat dalam flag "CTFlearn{Spring2019_is_not_secure!}", terdapat beberapa pelajaran yang dapat dipetik:

1. "Spring2019_is_not_secure": Pelajaran pertama yang dapat diperoleh adalah bahwa menggunakan kata kunci yang mudah ditebak dan prediktabil seperti "Spring2019" adalah tidak aman. Penting untuk menggunakan kata sandi yang kuat, yang terdiri dari kombinasi huruf (huruf besar dan kecil), angka, dan simbol-simbol yang sulit ditebak oleh orang lain.

2. "CTFlearn": Merujuk pada platform CTF (Capture The Flag) bernama CTFlearn. Pelajaran yang bisa diambil adalah pentingnya berpartisipasi dalam kompetisi atau tantangan keamanan semacam ini untuk meningkatkan pemahaman tentang keamanan komputer dan mengasah keterampilan dalam mencari celah keamanan.

Solusi yang dapat diambil dari flag tersebut adalah:

- Menghindari penggunaan kata kunci yang mudah ditebak dan prediktabil. Sebaiknya menggunakan kata sandi yang kuat dan unik untuk setiap akun atau layanan yang digunakan.
- Melakukan praktik keamanan yang baik seperti penggunaan otentikasi dua faktor (2FA), pembaruan reguler perangkat lunak, dan menjaga kerahasiaan informasi pribadi.
- Mengikuti kompetisi atau tantangan keamanan seperti CTF untuk terus meningkatkan pemahaman dan keterampilan dalam bidang keamanan komputer.