Add readme.md

readme.md

@@ -0,0 +1,387 @@
+# پروژه آموزشی: شبیه‌سازی حمله Brute Force در Kotlin
+
+در این تمرین می‌خواهیم ببینیم **کامپیوتر چگونه می‌تواند با امتحان کردن همه حالت‌ها یک رمز را پیدا کند.**  
+به این روش در امنیت کامپیوتر **Brute Force Attack** گفته می‌شود.
+
+در این برنامه:
+
+1. کامپیوتر یک **رمز ۴ رقمی تصادفی** می‌سازد.  
+2. سپس برنامه شروع می‌کند **همه اعداد از 0 تا 9999 را امتحان کردن**.  
+3. اگر یکی از آن‌ها با رمز برابر باشد، رمز پیدا می‌شود.
+
+---
+
+# کد کامل برنامه
+
+```kotlin
+import kotlin.random.Random
+
+fun main() {
+    var generatedPassword = ""
+    for (i in 0..3) {
+        val digit = Random.nextInt(10)
+        generatedPassword += digit.toString()
+    }
+
+    println("رمز تولید شده (فقط برای تست): $generatedPassword")
+
+    println("شروع تست brute force...")
+
+    for (i in 0..9999) {
+        println("تلاش برای $i ... ")
+
+        if (i == generatedPassword.toInt()) {
+            println("Found! رمز پیدا شد: $i")
+            break
+        }
+    }
+    println("پایان تست brute force.")
+}
+```
+
+---
+
+# مرحله ۱ — تولید رمز تصادفی
+
+```kotlin
+var generatedPassword = ""
+```
+
+در این خط یک **متغیر رشته‌ای (String)** ساخته‌ایم که قرار است رمز داخل آن ذخیره شود.
+
+در ابتدا مقدار آن خالی است.
+
+---
+
+```kotlin
+for (i in 0..3)
+```
+
+این یک **حلقه for** است.
+
+این حلقه **۴ بار اجرا می‌شود**:
+
+```
+0
+1
+2
+3
+```
+
+ما می‌خواهیم یک **رمز ۴ رقمی** بسازیم، پس این حلقه ۴ بار اجرا می‌شود تا ۴ رقم تولید کند.
+
+---
+
+```kotlin
+val digit = Random.nextInt(10)
+```
+
+اینجا یک **عدد تصادفی** تولید می‌کنیم.
+
+تابع:
+
+```
+Random.nextInt(10)
+```
+
+عددی بین این بازه تولید می‌کند:
+
+```
+0 تا 9
+```
+
+پس هر بار یک رقم تصادفی ساخته می‌شود.
+
+مثلاً:
+
+```
+3
+7
+1
+9
+```
+
+---
+
+```kotlin
+generatedPassword += digit.toString()
+```
+
+در این خط عدد تولید شده به **رشته تبدیل** می‌شود.
+
+چرا؟
+
+چون متغیر `generatedPassword` از نوع **String** است.
+
+مثال:
+
+```
+digit = 3
+```
+
+بعد از تبدیل:
+
+```
+"3"
+```
+
+حالا به رمز اضافه می‌شود.
+
+مثال روند ساخت رمز:
+
+```
+""   -> "3"
+"3"  -> "37"
+"37" -> "371"
+"371" -> "3719"
+```
+
+در نهایت رمز مثلاً می‌شود:
+
+```
+3719
+```
+
+---
+
+# نمایش رمز (فقط برای تست)
+
+```kotlin
+println("رمز تولید شده (فقط برای تست): $generatedPassword")
+```
+
+این خط فقط برای **آزمایش برنامه** است.
+
+در دنیای واقعی نباید رمز چاپ شود.
+
+اما برای اینکه ببینیم برنامه درست کار می‌کند آن را نمایش می‌دهیم.
+
+---
+
+# شروع حمله Brute Force
+
+```kotlin
+println("شروع تست brute force...")
+```
+
+فقط برای اطلاع دادن به کاربر است.
+
+---
+
+# حلقه اصلی Brute Force
+
+```kotlin
+for (i in 0..9999)
+```
+
+در اینجا برنامه همه اعداد ممکن را امتحان می‌کند.
+
+بازه:
+
+```
+0
+1
+2
+3
+...
+9999
+```
+
+چرا تا 9999؟
+
+چون رمز ما **۴ رقمی** است.
+
+تمام حالت‌های ممکن:
+
+```
+0000
+0001
+0002
+...
+9999
+```
+
+---
+
+# نمایش تلاش‌ها
+
+```kotlin
+println("تلاش برای $i ... ")
+```
+
+در هر مرحله برنامه نشان می‌دهد که چه عددی را در حال امتحان کردن است.
+
+مثلاً:
+
+```
+تلاش برای 0 ...
+تلاش برای 1 ...
+تلاش برای 2 ...
+...
+```
+
+---
+
+# بررسی درست بودن رمز
+
+```kotlin
+if (i == generatedPassword.toInt())
+```
+
+در اینجا بررسی می‌کنیم:
+
+آیا عددی که الان امتحان می‌کنیم (`i`)  
+با رمز واقعی برابر است؟
+
+اما یک نکته مهم وجود دارد.
+
+رمز ما از نوع **String** است:
+
+```
+"3719"
+```
+
+اما `i` یک **عدد (Int)** است.
+
+پس باید رمز را تبدیل کنیم:
+
+```
+generatedPassword.toInt()
+```
+
+مثال:
+
+```
+"3719" -> 3719
+```
+
+حالا می‌توانیم مقایسه کنیم.
+
+---
+
+# وقتی رمز پیدا شود
+
+```kotlin
+println("Found! رمز پیدا شد: $i")
+break
+```
+
+اگر رمز پیدا شود:
+
+1. پیام نمایش داده می‌شود.
+2. با دستور `break` از حلقه خارج می‌شویم.
+
+چرا؟
+
+چون دیگر لازم نیست ادامه بدهیم.
+
+---
+
+# پایان برنامه
+
+```kotlin
+println("پایان تست brute force.")
+```
+
+این خط نشان می‌دهد که برنامه تمام شده است.
+
+---
+
+# مفهوم Brute Force
+
+**Brute Force** یعنی:
+
+> امتحان کردن تمام حالت‌های ممکن تا زمانی که جواب پیدا شود.
+
+در این مثال:
+
+کامپیوتر این کار را انجام می‌دهد:
+
+```
+0000
+0001
+0002
+0003
+...
+3719 ✅
+```
+
+وقتی به رمز درست برسد، آن را پیدا می‌کند.
+
+---
+
+# نکته مهم
+
+تعداد حالت‌های ممکن برای رمز ۴ رقمی:
+
+```
+10000 حالت
+```
+
+اگر رمز ۶ رقمی باشد:
+
+```
+1,000,000 حالت
+```
+
+و اگر رمز طولانی‌تر باشد، پیدا کردن آن با brute force بسیار سخت‌تر می‌شود.
+
+به همین دلیل در سیستم‌های واقعی از:
+
+- رمزهای طولانی
+- محدودیت تعداد تلاش
+- captcha
+- قفل شدن حساب
+
+استفاده می‌شود.
+
+---
+
+# تمرین برای دانشجویان
+
+### تمرین ۱
+یک متغیر اضافه کنید و **تعداد تلاش‌ها** را بشمارید.
+
+در پایان برنامه چاپ کنید:
+
+```
+رمز بعد از 5321 تلاش پیدا شد
+```
+
+---
+
+### تمرین ۲
+کاری کنید که رمز **۵ رقمی** شود.
+
+---
+
+### تمرین ۳
+کاری کنید که برنامه **هر 1000 تلاش یک پیام نمایش دهد** تا خروجی خیلی شلوغ نشود.
+
+---
+
+### تمرین ۴ (چالش)
+
+به جای امتحان کردن همه اعداد از `0..9999`  
+با **۴ حلقه تو در تو** تمام حالت‌ها را بسازید.
+
+مثال:
+
+```
+0000
+0001
+0002
+...
+9999
+```
+
+---
+
+این تمرین به شما کمک می‌کند مفاهیم زیر را بهتر یاد بگیرید:
+
+- حلقه `for`
+- اعداد تصادفی
+- تبدیل نوع داده (`String` و `Int`)
+- شرط‌ها (`if`)
+- خروج از حلقه (`break`)
+- مفهوم Brute Force