BPROF:2dm

Ez a szócikk a "Rendszertervezés" tantárgy keretében keletkező dokumentum, mely része a szakdolgozat mellékleteinek. Tartalmazza a felhasznált technológia részletes leírását, informatikai felépítését. A dokumentum a reprodukálhatóság elősegítéséhez készült

Szakdolgozat alrendszerei

• GTS (Graphical Test Software), ez a tesztek lejátszására kifejlesztett szoftver

• GTDS (Graphical Test Designer Software), ez a tesztek tervezésére kifejlesztett szoftver

• Theme4GTS ,ez a témák létrehozására fejlesztett szoftver

• Language4GTS ,ez a nyelvek létrehozására fejlesztett szoftver

Fogalmak

(potenciális változók a kódhoz)

• puzzle: X-szer Y-os háló, melyben a sorfejléc (X) és oszlopfejléc (Y) attribútumok alapján kell elhelyezni az odaillő válaszkártyát
• X(i): sorfejléc, mely megadja a válaszkártya1. attribútumát
• Y(j): soszlopfejléc, mely megadja a válaszkártya2. attribútumát
• válaszkártya(k): képkocka, melyet el kell helyezni a megfelelő kockájába a hálónak
• megoldástér(i,j,k):
• keretrendszer: puzzle megjelenítő szoftver
• log: minden tevékenység (pl. egérmozgás, billentyű-leütés, billentyű-kombináció) feljegyzése egy fájlban, dátummal felcímkézve (vö. https://miau.my-x.hu/mediawiki/index.php/Excel-makro#Tanfolyami_vez.C3.A9r-feladatok)
• kiértékelés: válaszkártyák helyének helyességének ellenőrzése
• teszt:
• hiba:
• játék:
• rendszer
• réteg
• modul
• alrendszer
• szoftver
• licensz

Megrendelői kezdeményezés

Létezik egy 2DM-játék (https://miau.my-x.hu/miau/254/2dm_kemia_demo/), amelyben a feladat egy 3x3-as* hálóban különféle képeket elhelyezni az oszlop- és sor-fejlécek alapján. A létező 2DM-játék log-ja a vágólapra keletkezik a JavaScript lehetőségei mentén. Az új rendszerben a sebezhetőségek minimalizálása, csalás minden mennyiségű kizárása a cél.

Feladat:

• Új játék tervezését és
• futtatását támogató keretrendszer kialakítása úgy, hogy
  • a keretrendszer támogassa a puzzle megtervezését,
  • az adat-megjelenítést/adatbevitelt,
  • a puzzle megírását és
  • a log-elemzést (vö. https://miau.my-x.hu/mediawiki/index.php/Excel-makro - Tanfolyami vezérfeladat).
• a keretrendszer által olyan output kialakítása, mely a jelenlegi 2DM-megoldás által azonnal futtatható

Nem feladat:

• online kollaboratív munka támogatása
• adatbázis-alapú megoldás kialakítása

Jelenlegi 2DM játék

Struktúrája: A jelenleg már elkészült 2DM játék adatbeolvasását,adatstruktúráját ki kell nyomozni annak érdekében, hogy a dolgozatban készülő játék kompatibilis lehessen vele. Nyomozás lépései:

1. https://www.cyotek.com/downloads/info/setup-cyowcopy-1.9.0.822-x86.exe alkalmazás segytségével letöltöttem a https://miau.my-x.hu/miau/271/2dm/ weboldal összes fájlját
2. letöltött adatok megjelenítése
3. ebből egyetlen egy 2DM-játékhoz tartozó objektumok (vö. *BLANK*): ???
4. egy játékra egyszerűsített manuálisan lebutított saját lokális verzió tesztelése
5. régi 2DM-játék által igényelt specifikációk véglegesítése
6. egy régi 2DM-játék (értékes tartalommal történő) manuális előállítása a specifikációk alapján az új játék fejlesztője által
7. manuálisan készített saját játék tesztelése
8. ezen manuális saját játék új keretrendszerben való reprodukálása és az output tesztelése

Rendszer megrendelővel egyeztetett követelményei

Optimális (tesztelt)

....

Választott technológiák

• Programnyelv:
  • mobil:
    • Swift
• lokális adattárolás: JSON
• publikus adattárolás: Firebase NoSQL adatbázis
• Bevonni tervezett online szolgáltatások:
  • Általunk használandó:
    • ChatGPT
    • flowchart tervező
  • Általunk ajánlott:
    • nayuki.io/page/png-file-chunk-inspector
    • png/jpeg/gif ellenőrzése
    • helyesírásellenőrzés
    • szöveget tartalmazó kép helyesírás ellenőrzése
    • felolvasó robot esetén helyes-e a szöveg?
  • Ötletek

Vizuális követelmények

single Játéktervező nézetei

• nyitó kép (1.vizuális réteg):
  • tartalom:
    • logó
    • pl: copyright @ 2023 Sipos
    • termék neve
    • verziószám
    • elérhetőségek
      • weboldal
      • telefon
      • email
      • ...
  • forma:
    • betűméret
    • stílus
    • nyelv (nyelvválasztó, 0. vizuális réteg?)
    • ...
  • funkcionalitás:
    • automatikusan betöltődik
    • X másodpercig látható
    • legalább az elérhetőség kijelölhető
    • a nyitó képet a menük egyik alpontja újra betölti (kapcsolatok)

• ÁSZF/szerződés (2.vizuális réteg):
  • tartalom:
    • licensz típus
    • adatgyűjtés (GDPR)
      • játéktervező felel a GDPR általi nem érintettségért
      • log gyűjtés szabályrendszere. ezzel egyet kell értetni mind a játék tervezőt, mind a játék játszóját
    • copyright a képekre (felelősség játéktervező részéről, NEM a keretrendszer tervező részéről!)
    • halmazelméleti szabályok közlése a sor és oszlop fejlécre vonatkozóan
      • kihagyásmentesség (kihagyásmentességi chatGPT-teszt: pl. palacsinta-receptből kihagyott tojás esetén a meg-tudod-e-sütni-kérdésre nemleges válasz kell és az indoklás is logikus hiányrámutatást kell, hogy adjon)
      • átfedésmentesség (vö. halmazértelmezés chatGPT által: https://miau.my-x.hu/bprof/2023/chatgpt_sets.docx - a homogén halmazok (tortaszeleket) anomáliái felismertethetők, így a 2dm sor/oszlop-fejléc-tervezés chatGPT által is támogatható ) vö. https://www.youtube.com/watch?v=5cYYeuwYF_0
    • súgó elérhetősége
    • helyetérzékeny súgók elérhetősége
    • GYIK
  • forma
    • kiemelések
    • ugrópontok
      • email
      • weboldal
      • applikáción belüli ugrópont (pl.: helyetérzékeny súgók)
    • kijelölhetőségek
    • betűméret
    • betűstílus
  • funkcionalitás
    • ÁSZF archiválhatósága (letölthetősége ... )
    • súgók demója
    • ÁSZF accept/deny gomb/checkbox
    • Online adatbáziskapcsolat engedélyezése (ezt letiltva a felhasználó beszorítja magát a lokális adattérbe, ezt lehet később módosítani)
    • Accessibility nézet
      • színvakság
      • szoftveres felolvashatóság
      • élő billentyűkről szóló tájékoztatás
        • ne lehessen felesleges inputot megadni, engedélyezetlen eszközről
      • ...

• Menü (3. vizuális réteg)
  • tartalom
    • szingle játék tervezése (egyenlőre 3x3)
      • ellenőrzési elemek:
        • játék adatfájljainak elérésének megadása (létezik-e az elérési útvonal)
        • kép fájl típusok megadása listából (png, jpg, gif ...)
          • képfájl tartalom azonosság ellenőrzése (fizikai azonosság, másolatok más néven való ellenőrzése)
          • hiba üzenet ha nincs pontosan 17 db megfelelő formátumú képállomány
          • maximum felbontás ellenőrzése (hiba üzenet ha a méret/arány nem megfelelő pl.: 400x400)
          • kép permission olvashatóságának (read,write,execute) ellenőrzése
          • kép formátum önazonosságának ellenőrzése ( attól még, hogy .png, valóban kép-e a kép)
          • felső fájl méret ellenőrzése
          • színpaletta egyenszilárdságának ellenőrzése
          • vízjelmentesség ellenőrzése
          • (törvényi előírásokat nem sértő tartalom garantálása)
          • könyvtár olvashatóságának ellenőrzése
          • kép fájl tartalmaz-e káros kódot?
          • kép fájl nevek nem tartalmazhatnak speciális karaktereket (ékezet szóköz , fájlnév 1-17ig stb)
          • képek stílusa egyezik-e? (pl.: mindegyik kép eliptikus...)
      • képek játékba integrálása
        • 17 soros összerendező táblázat (1-17ig előre kitöltve felülírhatóság mellett és a felhasználó ehhez fog alkalmazkodni)
          • lapozó kép (1)
          • bal felső sarok (2)
          • oszlop bal (3)
          • oszlop közép (4)
          • oszlop jobb (5)
          • sor felső (6)
          • sor közép (7)
          • sor alsó (8)
          • válaszkártyák (9-17)
    • multi játék tervezése (csak single alapon)
      • integrálandó játékok számának megadása (2-től N-ig)
      • N db alkönyvtár megadása abban a sorrendben, amiben a játékok integrálandók (ezek a könyvtárak a single játék tervezés eredményeinek kell hogy legyenek)
      • játéktervező szoftver névjegyének ellenőrzése könyvtáranként
    • lokális adatfájl betöltése
    • játék indítása
    • online adatfájlok elérése katalógusosan
    • beállítások elérése
      • tervezői beállítások
        • időlimites-e a játék
        • éles vagy próba játék (lehet újrapróbálni...)
        • tesztíró azonosítási módja (pl.: anonim, belső kód ...)
        • ....

• • forma
    • ellenőrzési elemekről olvasmányos,színes visszaigazolás
  • funkcionalitás
    • játéktervezés:
      • ellenőrzési lépések után a felhasználót a lépések sikerességéről tájékoztatva:
        • megfelelő játéktípus szükséges alkotórészeinek új alkönyvtárba másolása
        • 1-17 képfájlok másolat készítése,átnevezése
        • játékindítás fejajánlása

Játékot használó vizuális rétegei

....

Egyéb követelmények

Internet elérése szükséges a Kvíz Katalógus használatához, hiszen csatlakoznia kell a Firebase adatbázishoz

Egyéb funkciók

• UI személyre szabása előre elkészített, akár a felhasználók által személyre szabott téma segítségével - (színvilág/színharmónia nem ellenőrzött, a téma tervezőjének kell figyelnie arra, hogy a felhasznált színek nem olvadnak egybe egymással)
• nyelvek támogatása, akár a felhasználók által definiált szótár segítségével - (szótár helyessége nem ellenőrzött, nincs kizárva akár a halandzsa nyelv használata sem)

Folyamatábrák

• Puzzle tervezésének folyamatábrája:........
  
• Puzzle megírásának folyamatábrája:........
  
• Puzzle kiértékelésének folyamatábrája:........
  

https://miau.my-x.hu/miau/292/2dm_figures/ folyamatabrak lesznek

IT biztonsági kérdések

• kulcsok tárolása a forráskódban?
  • nem a kódba fordítjuk bele a kulcsot, hanem valamilyen keychain szolgáltatásból nyeri ki
• Hálózaton keresztül történő adatátvitel feltörhetősége
• Logika nem a kliens,hanem a szerver oldalon kell, hogy tárolva legyen
• Adatbázishoz való hozzáférés kiosztása
  • https://miau.my-x.hu/mediawiki/index.php/BPROF:2dm#Adatb.C3.A1zis_jogosults.C3.A1gai
• JSON alapú lokális adattárolás megfelelősége
• régebbi verziójú keretrendszer használatának korlátozása, ezzel is csökkentve annak az esélyét, hogy egy már felefedezett sebezhetőségnek nem tesszük ki a felhasználót.
• képekhez kötődő károkozási formák feltárása
• kép eredeti (licensz kérdés nincs ha saját) vagy manipulált-e?
  • ...pdf url
  • elérési út alapján ellenőrizendő: létezik-e az objektum? (igen/nem)
    • nem = hibaüzenet a felhasználónak a helyes elérési útvonal kikényszerítésére
  • elérési útvonalban megadott fájl kiterjesztésének ellenőrzése (megfelel az előre fellistázott opcióknak/nem felel meg)
    • nem = hibaüzenet a felhasználónak a helyes kiterjesztés kikényszerítésére
  • elérési útvonalban megadott objektum jogosultságainak ellenőrzése (olvasható/nem olvasható)
    • nem = kérjük oldja fel, az olvashatóság korlátozását
  • a szóban forgó objektum megfelel-e a kiterjesztéshez kapcsolódó összes elvárásnak (igen/nem)
    • nem = hibaüzenet a felhasználónak, kérjük hozzon fel egy szabványos ... kiterjesztésű objektumot
    • igen =
      • ...pdf url........
      • https://www.nayuki.io/page/png-file-chunk-inspector
        • api curl kapcsolat lehetőségének operatív feltárása
  • kép méret,harmónia, ellenőrzése
    • ezeknek a sorrendje?
      • először méret, legvégén a harmónia
      • szerintem rettentő mindegy
    • kép ne olvadjon bele a futtató környezetbe
    • színharmónia megítélése
      • skálázható
      • mondhatja a szoftver, hogy szerinte ez csúnya
• SSL pinning (https://medium.com/trendyol-tech/securing-ios-applications-with-ssl-pinning-38d551945306 , https://www.kodeco.com/1484288-preventing-man-in-the-middle-attacks-in-ios-with-ssl-pinning)

Programnyelv

Több fajta programnyelvet kipróbáltam, ám legvégül IOS környezetben, Swift nyelvnél döntöttem. (https://miau.my-x.hu/mediawiki/index.php/BPROF:2dm#Swift) Felsorolom a kipróbált nyelveket, majd legvégül kifejtem a Swift fejezetet.

Desktop

https://www.freecodecamp.org/news/compiled-versus-interpreted-languages/#:~:text=Examples%20of%20pure%20compiled%20languages,Haskell%2C%20Rust%2C%20and%20Go.

Interpretált programnyelv

Az interpretált sorról sorra olvassák be a programot, és futtatnak le minden parancsot. Ezek a programnyelvek szignifikánsabban lassabbak, mint a fordított programnyelvek.
pl.: Python, Ruby

fordított programnyelv

Közvetlenül a CPU-ba vannak írva, és ezért gyorsabban lehet futtatni öket, mint az interpretált nyelveken íródott programokat. Hátránya, hogy a fejlesztéskor minden változtatás futtatásakor rebuildelni kell a teljes programot.
Előnye, hogy mivel a CPU-ba vannak írva, nehezebb hozzáférni a forráskódhoz. pl.: C++, Rust, Go

Konklúzió: Nem lesz logika tárolva a frontendben, ez a későbbi alfejezetekben lesz kifejtve.

Mobil

Swift

Proramozási nyelv:

/*Ide amit Rikk J. t.úr kért (OOP, output elemzés, hasznalt algoritmusok elemzese)*/

OOP:

sajat swift oop doksim*

Használt algoritmusok: ......

• https://www.reddit.com/r/iOSProgramming/comments/10vxfyo/security_of_an_ios_app/?utm_source=share&utm_medium=ios_app&utm_name=iossmf

• https://github.com/securing/IOSSecuritySuite

Lista rengeteg jailbreak detection elleni csomaggal:

https://heystacks.com/doc/229/combatting-jailbreak-detection

IT biztonság:

Ezt még a tesztelő folyamatosan teszteli, és amint sikerül haladnia, a dolgozatíró is fogja frissíteni itt, a miauban.

Ezek az alap IOSSecuritySuite modul által támogatott biztonségi metódusok. Ezeket módosítani, kiegészíteni szükséges, mivel sikerült az alap metódusokat kijátszania a tesztelőnek. A módosításokhoz GitHub-on szükséges egy Fork-ot készíteni, és azt használni később. Figyelembe kell venni a modul licenszét, ami 'BSD 2-Clause'. Ez a következőket jelenti:

Forrás: https://hu.wikipedia.org/wiki/BSD_licenc

A BSD licenc a szabad szoftverekkel kapcsolatos megengedő licenctípusok egy tagja, mely minimális megkötésekkel él az adott szoftver újraterjesztésére. A licenc szövegét az eredeti verzióról több felülvizsgálatot követően többször átalakították, a gyakorlatban három széles körben ismert változata terjedt el.

4 klauzulás licenc vagy eredeti BSD Licenc 3 klauzulás licenc vagy Revideált BSD Licenc vagy Új BSD Licenc vagy Módosított BSD Licenc 2 klauzulás licenc vagy Egyszerűsített BSD Licenc vagy FreeBSD Licenc A változatok közös jellemzője, hogy nem kötik ki a szabad szoftverek későbbi fejlesztések után (legyen a fejlesztő akárki) szabadként való továbbadását, illetve megengedik a szoftver átírását és bináris formában való terjesztését is.

Mivel azonban a BSD licencek változatai tartalmilag lényeges dolgokban el is térnek egymástól, a Free Software Foundation (FSF) arra kéri a programalkotókat, hogy legyenek pontosak, amikor megnevezik, melyik licenc alatt adják ki szellemi terméküket, így nem lehet keveredés a programozó szándéka és a felhasználó értelmezése között.[1]

A Free Software Foundation a BSD licenc mindhárom változatát szabad szoftverű licencként ismerte el, az Open Source Initiative nevű szervezet ugyanakkor csak a 2 és 3 klauzulás változatról nyilvánította ki, hogy megfelel a nyílt forrású licencekkel szemben támasztott követelményeknek. Hozzá kell tenni, hogy bár az FSF a 4 klauzulás változatot szabad szoftverű licenctípusnak fogadta el, nem találja együtt használhatónak a GPL különböző változataival, vagyis velük inkompatibilis.

• Jailbreak (root jogosultság) felismerése (vö. https://en.wikipedia.org/wiki/IOS_jailbreaking#:~:text=On%20Apple%20devices%20running%20iOS,a%20series%20of%20kernel%20patches). Ez se nem a dolgozatíró, se nem a tesztelő saját szoftvere (eredeti szoftver vö.: https://github.com/securing/IOSSecuritySuite), itt a cél, a metódus működésének feltérképezése volt, IT biztonsági szempontból.)

<key>LSApplicationQueriesSchemes</key>
<array>
   <string>undecimus</string>
   <string>sileo</string>
   <string>zbra</string>
   <string>filza</string>
   <string>activator</string>
</array>

func checkJailbreak() {
       let jailbreakStatus = IOSSecuritySuite.amIJailbrokenWithFailMessage()
       if jailbreakStatus.jailbroken {
           print("This device is jailbroken")
           print("Because: \(jailbreakStatus.failMessage)")
       } else {
           print("This device is not jailbroken")
       }
   }

Mit csinál a "checkJailbreak" nevű függvény?

func checkJailbreak() -> Bool {
       let jailbreakStatus = IOSSecuritySuite.amIJailbrokenWithFailMessage()
       let findLoadedDylibs = IOSSecuritySuite.findLoadedDylibs()
       let amIReverseEngineered = IOSSecuritySuite.amIReverseEngineered()
       
       print("findLoadedDylibs: \(String(describing: findLoadedDylibs))")
       print("amIReverseEngineered: \(amIReverseEngineered)")
       
       if jailbreakStatus.jailbroken {
           print("This device is jailbroken")
           print("Because: \(jailbreakStatus.failMessage)")
           return true
       } else if amIReverseEngineered {
           print("IamReverseEngineered")
           return true
       } else {
           print("This device is not jailbroken")
           return false
       }
   }

A következőkben felbontom, hogy milyen komponensek vannak a "checkJailbreak" függvényben, minden alfüggvénnyel együtt. Ennek célja, hogy teljesen felfedjem a jailbreak detection rendszert.

• IOSSecuritySuite.amIJailbrokenWithFailMessage()

public static func amIJailbrokenWithFailMessage() -> (jailbroken: Bool, failMessage: String) {
       return JailbreakChecker.amIJailbrokenWithFailMessage()
   }

Mit csinál az "amIJailbrokenWithFailMessage" nevű függvény?

static func amIJailbrokenWithFailMessage() -> (jailbroken: Bool, failMessage: String) {
       let status = performChecks()
       return (!status.passed, status.failMessage)
   }

Mit csinál a "performChecks" nevű függvény?

private static func performChecks() -> JailbreakStatus {
       var passed = true
       var failMessage = ""
       var result: CheckResult = (true, "")
       var failedChecks: [FailedCheckType] = []
       
       for check in FailedCheck.allCases {
           switch check {
           case .urlSchemes:
               result = checkURLSchemes()
           case .existenceOfSuspiciousFiles:
               result = checkExistenceOfSuspiciousFiles()
           case .suspiciousFilesCanBeOpened:
               result = checkSuspiciousFilesCanBeOpened()
           case .restrictedDirectoriesWriteable:
               result = checkRestrictedDirectoriesWriteable()
           case .fork:
               if !EmulatorChecker.amIRunInEmulator() {
                   result = checkFork()
               } else {
                   print("App run in the emulator, skipping the fork check.")
                   result = (true, "")
               }
           case .symbolicLinks:
               result = checkSymbolicLinks()
           case .dyld:
               result = checkDYLD()
           default:
               continue
           }

           passed = passed && result.passed

           if !result.passed {
               failedChecks.append((check: check, failMessage: result.failMessage))

               if !failMessage.isEmpty {
                   failMessage += ", "
               }
           }

           failMessage += result.failMessage
       }

       return JailbreakStatus(passed: passed, failMessage: failMessage, failedChecks: failedChecks)
   }

Ez a Swift kód egy függvényt definiál, amelynek neve performChecks(). Az a célja, hogy ellenőrizze, hogy a készülék, amelyen az alkalmazás fut, jailbreakelt-e (azaz az operációs rendszer biztonsági korlátait kikerülték a készüléken).

A függvényt JailbreakStatus típusú értékkel tér vissza, amelynek három eleme van: passed (egész szám, amely igaz vagy hamis értéket vesz fel), failMessage (szöveg) és failedChecks (FailedCheckType típusú tömb). A passed logikai érték megadja, hogy az összes ellenőrzés során sikeres volt-e, a failMessage tartalmazza az összes hibát, amelyet a tesztek során találtak, és a failedChecks pedig tartalmazza azokat a teszteket, amelyek során hiba történt.

A függvény kezdetén a változók inicializálódnak: passed igaz, failMessage üres sztring, result logikai értékből és szövegből álló tuple, amelynek kezdőértéke (true, ""), és failedChecks üres FailedCheckType tömb.

Ezután a függvény végigiterál az összes FailedCheck típusú értéken (FailedCheck egy enumeráció). Mindegyik tesztesetet végrehajtja a switch utasítással. Az első teszteset urlSchemes, és az checkURLSchemes() függvényt hívja meg. A következő teszteset existenceOfSuspiciousFiles, amely az checkExistenceOfSuspiciousFiles() függvényt hívja meg, és így tovább minden tesztesetre.

Minden teszteset eredménye (result) eltárolódik a passed és failMessage változókban. Ha az adott teszteset eredménye sikertelen, akkor hozzáadjuk a failedChecks tömbhöz, hogy az összes hibát nyomon követhessük. Ha az adott teszteset eredménye sikertelen, akkor hozzáadjuk az adott hibaüzenetet a failMessage változóhoz, amely tartalmazza az összes teszteset során talált hibákat.

Végül a függvény visszatér a JailbreakStatus értékével, amely tartalmazza az összes teszt eredményét.

• IOSSecuritySuite.findLoadedDylibs()

static func findLoadedDylibs(_ target: IntegrityCheckerImageTarget = .default) -> [String]? {
       return IntegrityChecker.findLoadedDylibs(target)
   }

Mit csinál a "findLoadedDylibs" nevű függvény?

Meghívja a következő függvényt, az IntegrityChecker osztályból:

static func findLoadedDylibs(_ target: IntegrityCheckerImageTarget = .default) -> [String]? {
       switch target {
       case .custom(let imageName):
           return MachOParse(imageName: imageName).findLoadedDylibs()
       case .default:
           return MachOParse().findLoadedDylibs()
       }
   }

Mit csinál az "IntegrityChecker" osztályban található "findLoadedDylibs" függvény?

A dinamikus könyvtárakat keresi egy adott célfolyamatban. A függvény egy opcionális IntegrityCheckerImageTarget típusú paramétert vár. A switch utasításban az IntegrityCheckerImageTarget típus értékétől függően a függvény két különböző esetben hajtódik végre. Az alapértelmezett esetben (case .default) a MachOParse objektumot példányosítjuk a default konstruktorral, és meghívjuk rajta a findLoadedDylibs() metódust, amely visszaadja az összes betöltött dinamikus könyvtárat a folyamatban. A másik esetben (case .custom(let imageName)) az adott imageName nevű fájlra hajtunk végre hasonló műveleteket, majd visszatérünk a talált dinamikus könyvtárak listájával. A visszatérési érték egy opcionális tömb típusú érték, amely tartalmazza a betöltött dinamikus könyvtárak neveit. Ha nincsenek betöltött dinamikus könyvtárak, akkor a függvény nil-t ad vissza.

• IOSSecuritySuite.amIReverseEngineered()

public static func amIReverseEngineered() -> Bool {
       return ReverseEngineeringToolsChecker.amIReverseEngineered()
   }

Mit csinál az "amIReverseEngineered" nevű függvény?

static func amIReverseEngineered() -> Bool {
       return !performChecks().passed
   }

A függvény egyszerűen meghívja a performChecks() függvényt, amely visszaadja egy JailbreakStatus értéket, amely tartalmazza az alkalmazásban végrehajtott biztonsági ellenőrzések eredményeit. Az eredmény szerint, ha az összes ellenőrzés sikeres volt, és nincs biztonsági probléma, akkor a passed tulajdonság igaz értéket ad vissza, és az alkalmazás nem lett megfordítva.

A ! (negáció) operátorral azonban megfordítjuk az értéket, és ha bármelyik ellenőrzés megbukott, azaz az passed tulajdonság hamis értéket adott vissza, akkor a performChecks() függvényből visszatérő érték hamis lesz, mivel az alkalmazás nem teljesíti a biztonsági előírásokat. Ebben az esetben a amIReverseEngineered() függvény is hamis értékkel tér vissza, mivel a megfordítás (reverse engineering) előfeltétele a biztonsági ellenőrzések sikeres teljesítése. Így ha az amIReverseEngineered() függvény hamis értéket ad vissza, akkor az azt jelzi, hogy az alkalmazás nem lett megfordítva. Ellenkező esetben, ha igazat ad vissza, akkor az azt jelzi, hogy az alkalmazás meg van fordítva.

• performChecks()

private static func performChecks() -> ReverseEngineeringToolsStatus {
       var passed = true
       var result: CheckResult = (true, "")
       var failedChecks: [FailedCheckType] = []
       
       for check in FailedCheck.allCases {
           switch check {
           case .existenceOfSuspiciousFiles:
               result = checkExistenceOfSuspiciousFiles()
           case .dyld:
               result = checkDYLD()
           case .openedPorts:
               result = checkOpenedPorts()
           case .pSelectFlag:
               result = checkPSelectFlag()
           default:
             continue
           }

           passed = passed && result.passed

           if !result.passed {
               failedChecks.append((check: check, failMessage: result.failMessage))
           }
       }

       return ReverseEngineeringToolsStatus(passed: passed, failedChecks: failedChecks)
   }

Mit csinál a "ReverseEngineeringToolsChecker" osztályban található "performChecks" függvény?

Az alkalmazásban keresi az olyan potenciális fordítási eszközök és technikák jelenlétét, amelyekkel az alkalmazást meg lehet fordítani (reverse engineering). A függvény neve performChecks, és nem vár paramétert.

A függvény egy üres ReverseEngineeringToolsStatus objektummal kezdődik, majd végrehajtja az összes definiált ellenőrzést a FailedCheck enumerációban. Az enumerációban definiált ellenőrzések a következők:

existenceOfSuspiciousFiles: Ellenőrzi az alkalmazásban lévő gyanús fájlok jelenlétét.

dyld: Ellenőrzi az alkalmazás dyld rendszerhívásait, amelyeket használhatnak a fordítási eszközök.

openedPorts: Ellenőrzi, hogy az alkalmazás nyitott-e hálózati portokat, amelyek lehetővé tehetik a támadók számára az alkalmazás kémkedését.

pSelectFlag: Ellenőrzi, hogy az alkalmazás használja-e a pselect() rendszerhívást, amelyet a fordítási eszközök használhatnak a hibakereséshez.

Az ellenőrzések végrehajtása során a függvény megvizsgálja az összes ellenőrzési eredményt, és ha az ellenőrzés sikeres, akkor az passed tulajdonságot igazra állítja, különben hamisra. Az összes sikeres ellenőrzés után az passed tulajdonsága igaz marad, különben hamis lesz.

Ha egy ellenőrzés nem sikerült, akkor a függvény hozzáadja az ellenőrzést a failedChecks tömbhöz. Ez azért fontos, mert az alkalmazás esetlegesen használhat olyan eszközöket, amelyek nem jelentenek kockázatot a biztonságra, és nem szeretnénk téves riasztást okozni.

Végül a függvény egy ReverseEngineeringToolsStatus objektumot ad vissza, amely tartalmazza az összes ellenőrzés eredményeit. Ha az összes ellenőrzés sikeres volt, akkor az passed tulajdonság igazra állítódik, különben hamisra. A failedChecks tömbben találhatók azok az ellenőrzések, amelyek nem voltak sikeresek, és ezt a ReverseEngineeringToolsStatus objektumot használják arra, hogy az alkalmazás megfelelően értékelje az alkalmazás biztonsági helyzetét, és megvédje azt a fordítási

Mi a ReverseEngineeringToolsStatus?

 ReverseEngineeringToolsStatus {
       let passed: Bool
       let failedChecks: [FailedCheckType]
   }

Ez az adattípus segít visszaadni az összes ellenőrzés eredményét a performChecks függvényben, hogy a függvény hívója könnyen ellenőrizhesse az eredményeket és választhatjon a megfelelő további műveletek közül.

'passed' egy logikai érték, amely azt jelzi, hogy az ellenőrzések átmentek-e vagy sem. 'failedChecks' egy [FailedCheckType] típusú tömb, amely azokat az ellenőrzéseket tartalmazza, amelyek nem mentek át, és a hibás üzenetüket.

Mi a FailedCheckType?

public typealias FailedCheckType = (check: FailedCheck, failMessage: String)

public enum FailedCheck: CaseIterable {
   case urlSchemes
   case existenceOfSuspiciousFiles
   case suspiciousFilesCanBeOpened
   case restrictedDirectoriesWriteable
   case fork
   case symbolicLinks
   case dyld
   case openedPorts
   case pSelectFlag
}

FailedCheckType - Egy típusaliasz, amely egy tuple-t definiál. A tuple két elemet tartalmaz: egy FailedCheck típusú értéket és egy szöveges üzenetet a hiba okának megadására. FailedCheck - Ez egy felsorolási típus (enum), amely tartalmazza azokat az ellenőrzéseket, amelyeket a kód végrehajt, hogy meghatározza, hogy az alkalmazás éppen visszafejtett állapotban van-e vagy sem. Minden enum eset (case) az adott ellenőrzési típus nevét tartalmazza, például urlSchemes, existenceOfSuspiciousFiles, dyld, stb. Ez az enum fontos szerepet játszik a performChecks függvényben, amely minden FailedCheck esetét végigmegy, és elvégzi az adott ellenőrzést. Ha az ellenőrzés nem sikerül, a függvény hozzáadja az adott FailedCheckType elemet a failedChecks tömbhöz.

Ennek teszteléséhez szükség van egy Jailbreak-elt iOS eszközre. Ezt a lent megemlített tesztelő biztosítja.

A teszt eszköz specifikációjai:

• Gyártó: Apple
• Modell: iPhone 6S
• Verzió: 14.7.1

Tesztelt metódusok:

• SSL Pinning

Az SSL pingelés azt jelenti, hogy egy készülék teszteli, hogy egy másik számítógép vagy szerver SSL/TLS titkosítást használ-e az adatkapcsolatánál. Az SSL/TLS a Secure Sockets Layer/Transport Layer Security protokolljai, amelyek kétoldalú titkosítást biztosítanak a kommunikációhoz, így megakadályozzák az adatok illetéktelen hozzáférését vagy megváltoztatását.

Az SSL pingelés egy olyan módszer, amely megállapítja, hogy egy adott szerver milyen gyorsan és megbízhatóan reagál SSL kapcsolatokra. Az IOS készülékek esetében az SSL pingelés általában egy olyan alkalmazás által történik, amely az adatkapcsolatokat kezeli, például egy böngésző vagy egy e-mail alkalmazás. Az SSL pingelés eredményei segíthetnek az alkalmazásnak meghatározni, hogy melyik szerverrel lehet a legjobb kapcsolatot létesíteni, és így javíthatják az alkalmazás teljesítményét és a felhasználói élményt.

• App Attest Service

Az App Attest Service az Apple által az iOS 14 és az újabb verziókban bevezetett szolgáltatás, amely lehetővé teszi az alkalmazások számára, hogy igazolják a biztonságos futásukat az Apple rendszerén belül. Az App Attest Service a biztonsági kulcsokat és az Apple T2 chipjének használatával valósítja meg a biztonságos alkalmazások ellenőrzését.

Az App Attest Service szolgáltatás segítségével az alkalmazások egyedi azonosítóval rendelkező igazolást kérhetnek az Apple-től, amely igazolja, hogy az adott alkalmazás hiteles és az Apple rendszerében fut. Az igazolás tartalmazza a kulcsot, amelyet az alkalmazás felhasználhat az alkalmazás eredetiségének és biztonságosságának bizonyításához, például azonosításra szolgáló tokenek, a biztonságos kommunikációhoz használt titkosított kulcsok és egyéb funkciók esetén.

Az App Attest Service segít az alkalmazásoknak biztosítani, hogy csak az eredeti, biztonságosan fejlesztett kód fut a rendszerben, és segíthet megelőzni az adathalászatot, a csalásokat és a biztonsági kockázatokat. Az alkalmazásfejlesztőknek azonban támogatniuk kell az App Attest Service használatát az alkalmazásukban, hogy maximális biztonságot érhessenek el.

• Hide current view on applicationWillResignActive
• Prevent Logging in Production, ...

• Function Hooking

A "function hooking" olyan technika, amely lehetővé teszi, hogy a programozó megváltoztassa egy program futás közbeni működését azáltal, hogy megváltoztatja annak függvényhívásait. A Swift programozási nyelvben ez azt jelenti, hogy a programozó a program futása közben hozzáadhat kódot egy függvényhívás előtt vagy után, hogy megváltoztassa a függvény eredményét vagy működését.

A function hooking általában olyan rendszerszintű programokban használatos, amelyek a rendszerhívásokat módosítják, de néhány esetben a fejlesztők is használhatják, például hibakereséshez vagy teszteléshez.

A Swiftben a function hooking megvalósítása az alacsony szintű C funkciók használatával lehetséges, például a dlsym() és dlopen() függvényekkel. A function hooking azonban erős függőséget mutat a rendszerbeli struktúrákra, és általában nem ajánlott átlagos fejlesztőknek, mivel hibákat és instabilitást okozhat a rendszerben.

• Módosítások az alkalmazásban

Az IOSSecuritySuite egy harmadik féltől származó keretrendszer, amelyet az alkalmazás biztonságának javítására lehet használni. A fenti kódrészletek azt ellenőrzik, hogy az alkalmazásunkat manipulálták-e.

Ha hozzá szeretnénk adni az alkalmazásunkhoz, akkor először importálnunk kell az IOSSecuritySuite keretrendszert a projektünkbe. Ezután az alkalmazásunkban meg kell hívni a fenti függvényeket, amelyek visszatérnek egy eredmény struktúrával, amely tartalmazza a baszogatás eredményét.

A kód szerint az első függvény (amITampered) ellenőrzi, hogy az alkalmazásunkat manipulálták-e az adott bundleID-vel, mobileProvision-nel és machO fájl SHA256 hash-jével. Az eredmény egy result logikai érték, amely megmondja, hogy az alkalmazásunkat manipulálták-e vagy sem.

A második függvény (getMachOFileHashValue) visszaadja az adott Mach-O fájl SHA256 hash-jét. Az első példa custom paramétere az IOSSecuritySuite keretrendszer saját Mach-O fájlját használja. Az eredmény alapján az alkalmazásunkat manipulálták-e vagy sem.

A harmadik függvény (a példában kommentként megjegyezve) ellenőrzi az alkalmazásunk saját hash-értékét, amelyet a szerverről lehet lekérni.

Fontos megjegyezni, hogy az IOSSecuritySuite csak egy eszköz az alkalmazás biztonságának javítására. Az alkalmazás biztonságának javítása érdekében többféle eszközt kell használni, beleértve a kódellenőrzést, a titkosítást és az egyéb biztonsági mechanizmusokat.

if IOSSecuritySuite.amITampered([.bundleID("biz.securing.FrameworkClientApp"),
   .mobileProvision("2976c70b56e9ae1e2c8e8b231bf6b0cff12bbbd0a593f21846d9a004dd181be3"),
   .machO("IOSSecuritySuite", "6d8d460b9a4ee6c0f378e30f137cebaf2ce12bf31a2eef3729c36889158aa7fc")]).result {
   print("módosítottak")
}
else {
   print("nem módosítottak.")
}

if let hashValue = IOSSecuritySuite.getMachOFileHashValue(.custom("IOSSecuritySuite")), hashValue == "6d8d460b9a4ee6c0f378e30f137cebaf2ce12bf31a2eef3729c36889158aa7fc" {
   print("nem módosítottak.")
}
else {
   print("módosítottak.")
}

if let hashValue = IOSSecuritySuite.getMachOFileHashValue(.default), hashValue == "your-application-executable-hash-value" {
   print("nem módosítottak semmit.")
}
else {
   print("módosítottak.")
}

IT Bizonság tesztelése

Tesztelés elvégzője: Jkv3 , aki nem a szakdolgozat készítője. A tesztelő által készített teszt eredményeket a szakdolgozat készítője feldolgozta és implementálta a szükséges kódot.

https://canijailbreak.com

IOS-es fájlkezelővel megnyitotta az alkalmazás tartalmát:

IMG-állományok (ZIP): https://miau.my-x.hu/miau/292/2dm_figures/GTS%20ios%20app%20ITB%20k.zip 

• IMG_0001.png , IMG_0010.png, firebase_url.png

A firebase adatbázis url-je. Az urlt nem lehet megnyitni böngészőből, ehhez a tulajdonos (jelen esetben a dolgozatíró) Google azonosítójával kell bejelentkezni a firebase szolgáltatásba.

• IMG_003.png

Az alkalmazást ki lehet bontani egy szoftver segítségével. A szoftver megjeleníti az alkalmazáson belüli függvényeket, fájlok neveit, fontosabb kódrészleteket.

• IMG_0005.png

Itt megtalálható minden alkalmazás fájl. Nyelvi fájlok (Localizable.strings) , Property list fájlok (.plist), és egyéb, az app futtatásához szükséges fájlok.

• IMG_0006.png , IMG_007.png, IMG_008.png

Ez a nyelvi fájl. Itt deklarálódik, hogy melyik kifejezés éppen melyik nyelven miként jelenjen meg.

• IMG_009.png

Ez maga az alkalmazás konfigurációs fájlja. Itt az érzékeny adat az “EMAIL” és “PASSWORD” mezőkben található. Ezt a dolgozatíró szánt szándékkal készítette így, mivel ez is egy módszer, egy alkalmazásbeli kulcs tárolásra.

Van rá lehetőség más módon tárolni ezeket a kulcsokat, elképzelhető, hogy a későbbiekben megváltozik a dolgozatban használt technológia.

https://www.securing.pl/en/the-secure-way-to-store-secrets-on-ios-devices/

“This also can be hacked if the hacker can have access to the archive file of our iOS. But this can be only shared with the people inside the company only, so I may not see this as a high threat.”

- https://medium.com/@karthianandhanit/how-to-securely-handle-the-third-party-keys-in-ios-adc6266efc1f

A teszt elvégzője szeretné hangsúlyozni, hogy ezekhez az adatokhoz való hozzáférés az IOS rendszerben mezei felhasználó számára nem kivitelezhető, root jogosultság, személyre szabott boot loader, kernel patchelés és még sok minden szükséges. Rengeteg ember foglalkozik ezzel (ki hobbi/ki professzionális szinten), hogy az éppen aktuális IOS-t “jailbreak”-eljék. Sem a teszt elvégzőjének, sem a dolgozatírónak nem ez volt a célja.

Jailbreak detection blocking https://ios.cfw.guide/blocking-jailbreak-detection/ https://www.reddit.com/r/jailbreak_/comments/qjr9h2/whats_the_best_jailbreak_detection_bypass_ios_144/

Keresnii kell egy olyan csomagot (tweak) amivel sikerül a jailbreak detectiont megtörni. Ennek a lényege,hogy újabb biztonsági rést fedezhessen fel a tesztelő, amit a dolgozatíró ledokumentálhat és befoltozhat.

• A "A-Bypass" tweak: nem sikerult a jailbreak bypass

• B "Liberty Lite" tweak: nem sikerült a jb bypass

• C "Shadow" tweak:
  • C1 Alap konfigurációval, bypass letiltásával nem indul el az app
  • C2 Alap konfigurációval, bypassal elindul az app, sikerül a bypass.
    • konfiguráció:
      • ...
    • log:

2023-02-21 11:45:43.944912+0100 GTSios[4366:30352] isPathRestricted: restricted: /Applications/Cydia.app 2023-02-21 11:45:43.948361+0100 GTSios[4366:30352] isPathRestricted: allowed: /Applications 2023-02-21 11:45:43.948458+0100 GTSios[4366:30352] isPathRestricted: allowed: /Applications 2023-02-21 11:45:43.948613+0100 GTSios[4366:30352] isPathRestricted: allowed: /Library/Ringtones 2023-02-21 11:45:43.948676+0100 GTSios[4366:30352] isPathRestricted: allowed: /Library/Ringtones 2023-02-21 11:45:43.948838+0100 GTSios[4366:30352] isPathRestricted: allowed: /Library/Wallpaper 2023-02-21 11:45:43.948896+0100 GTSios[4366:30352] isPathRestricted: allowed: /Library/Wallpaper 2023-02-21 11:45:43.949182+0100 GTSios[4366:30352] isPathRestricted: allowed: /usr/libexec 2023-02-21 11:45:43.949301+0100 GTSios[4366:30352] isPathRestricted: allowed: /usr/libexec 2023-02-21 11:45:43.949515+0100 GTSios[4366:30352] isPathRestricted: allowed: /usr/share 2023-02-21 11:45:43.949579+0100 GTSios[4366:30352] isPathRestricted: allowed: /usr/share

Tesztelt prorgamnyelvek

C#

Feltörése C# visszafejtése JetBrains dotPeek szoftver segítségével: https://miau.my-x.hu/mediawiki/index.php/BPROF:Csharp_Visszafejt%C3%A9se

---

Ruby

Mivel nem fordított nyelv, ezért a kódot nem lehet "elrejteni". A program egy *.rb fájl lenne, és ezt kellene futtatni egy interpreter segítségével. Emiatt a Ruby programnyelv használatát elvetem (a szakdolgozat GUI részének megvalósításához)

Feltörése

Nincs szükség rá,mivel magát a script fájlt futtattam le

---

Rust

Fordított programnyelv, tehát IT biztonsági szempontból megfelelő.

---

Logika tárolása

A keretrendszer logikáját nem maga a kliens,hanem a szervernek kellene kezelnie

Backend

Itt kell a logikát tárolni. (azaz,hogy a képkockák jo helyen vannak -e Feladat: megfelelő backed service-t találni

Lista lehetséges backend service-kről:

• heroku.com (fizetős)
• aws

Frontend

Itt nem kellene semmi logikát tárolni, csak az adatokat megfelelő módon átadni a backendnek Feladat: megtalálni a megfelelő frontend setupot. Megfelelő = szép, kultúrált, lehetőleg multiplatform supportos Kiválasztott: electron

---

licenszelés

A szoftver licensszel való védése már egy erős IT biztonsági lépés.

ki kaphat licenszt?

Ingyen kellene adni, mert nem tartom reálisnak, hogy a tanárok/iskolák erre költenének. -> önkormányzatoknak kellene ezeket managelni?

Licensz tárolása adatbázisban (Firebase)

_______________________________
| licensz tulaj | licensz kód |
###############################
| ............. | ........... |
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

Amelyik kód bent van az adatbázisban a megfelelő rekordokkal, az hozzáférhet a programhoz

licensz generálása

Szerveren° futtatandó scriptnek kellene kérésre generálnia licensz kulcsokat, és azokat eltárolni a Firebase-s adatbázisban

° milyen szerveren?

Lokális adattárolás

Nem éppen megfelelő az alkalmazás adatait JSON fájlokban tárolni. pl.: .db fájlban tárolni? https://learn.microsoft.com/en-us/windows/apps/design/app-settings/store-and-retrieve-app-data

Szoftverben használt csomagok és azok licenszeik

majd a végén, amikor kész lesz a szoftver

Log rendszer

A rendszer minden felhasználói tevékenységet feljegyez mind fejlesztési, mind a csalás elkerülése érdekében. A teszt fejlesztője megmondhatja, hogy mennyire kell szigorúan venni a szabályokat:

• minden csalás tiltott, első attrocitás esetén a teszt lezárul, a log elkészül
• csalások nincsenek engedélyezve, ám nem zár le a keretrendszer, csak logolja, hogy ez és ez történt
• szabadon lehet csalni
• beállíthatjuk, hogy mit vegyen csak figyelembe a rendszer. (indoklása: pl moodlen feltöltött anyagokat lehet használni, de más internetes keresést stb... nem)

Jelenleg logolható

• app minimalizálása, bezárása, puzzle elindítása

Tervezett funkciók

• internet használat elemzés (van-e esetleg olyan kulcsszavú keresés, mint amilyen szavak/kifejezések vannak az éppen aktív puzzle fájljaiban?)
• egérmozgás elemzés (mennyire határozott a teszt író -> túl nagy határozottság akár azt is jelentheti, hogy valahonnan megszerezte a megoldásokat a teszthez ?)
• ismert közösségi,csevegésre használt alkalmazások meg vannak-e nyitva (Messenger,Discord,facebook.com,Skype,Teams stb), ezek csalásra adhatnak lehetőséget
• külső meghajtók vannak-e csatolva
• adat mozgatás történt-e a számítógépen a teszt írása közben (x lokációról y lokációra való fájl mozgás)
• operációs rendszerre telepített képfelismerési program detektálása
• távolról van-e vezérelve a gép
• képernyőkép készítésének logolása
• automatikus egér mozgató (ha van ilyen, https://2b2t.miraheze.org/wiki/Baritone) auto clicker detektálása
• ...

Log elemzés

ez is olyan fontos lesz mint az ITB stb.....

Rendszerspecifikáció

Ajánlott irodalom/demo/minta: http://centroszet.hu/tananyag/ - pl. http://centroszet.hu/tananyag/szervezes2/615_rszletes_rendszerterv.html 

Program specifikáció

A követekző alfejezetben fogom összegyűjteni a program különféle specifikációját

User interface

Választott UI technológia

UIKit

Az UIKit az Apple által kifejlesztett keretrendszer az iOS alkalmazásokhoz, amelyeket iPhone, iPad és iPod Touch készülékeken futtatnak. Az UIKit lehetővé teszi az alkalmazások felhasználói felületének (UI) fejlesztését, amely az alkalmazások vizuális és interaktív aspektusait foglalja magában. Az UIKit tartalmaz egy sor előre elkészített UI elemeket, amelyeket könnyen hozzá lehet adni az alkalmazásokhoz, például gombokat, címkéket, képeket, szövegeket és sok más elemet. Az UIKit további funkciói közé tartozik az animációk és átmenetek, a szövegszerkesztés, az értesítések, az interakciók és az adatkezelés. Az UIKit egy nagyon hasznos eszköz az iOS alkalmazások fejlesztéséhez, és az iOS fejlesztők általánosan használt keretrendszerek közé tartozik.

Alternatívák

SwiftUI

A SwiftUI az Apple által kifejlesztett keretrendszer, amely lehetővé teszi az alkalmazások gyors és egyszerű felhasználói felületének (UI) kialakítását az iOS, az iPadOS, a macOS, a watchOS és a tvOS operációs rendszerekhez. A SwiftUI egy deklaratív programozási megközelítést kínál, amely lehetővé teszi az alkalmazások UI-jának kódolását egy egyszerű és intuitív módon. Az alkalmazás UI-ját előzetesen definiált építőelemekkel lehet létrehozni, amelyeket egyszerűen be lehet illeszteni a kódba, és a SwiftUI automatikusan megjeleníti az alkalmazásban.

A SwiftUI lehetővé teszi a fejlesztők számára az alkalmazások UI-jának gyors és hatékony tervezését és testreszabását. Az építőelemek sokfélesége lehetővé teszi az egyedi és összetett UI-k létrehozását. Az alkalmazások kódjának egyszerűsége és olvashatósága miatt az alkalmazások fejlesztése és karbantartása is gyorsabb és hatékonyabb lehet a SwiftUI használatával.

A Swift és a SwiftUI kiegészítik egymást, mivel a Swift lehetővé teszi a hatékony kódírást, míg a SwiftUI lehetővé teszi a gyors és egyszerű UI kialakítást. Az együtt használatuk lehetővé teszi az alkalmazások fejlesztőinek a hatékony, olvasható és testre szabható alkalmazások kódolását, és a gyors és egyszerű alkalmazások UI-jának kialakítását az Apple platformokra.

Adattárolás

Eredeti, elvetett ötlet

Githubon organizációban tárolt adatok. Hozzáfárés engedélyrzése esetén lehetett ide publikálni repositorykat. Ez se informatikailag, se IT biztonságilag nem volt megfelelő ötlet, ám nem kellett adatbázist fenntartani hozzá.

Lokális adattárolás választott formája

• A JSON fájlok egyszerű olvashatósága, értelmezhetősége miatt bárki létre tud hozni saját témát, nyelv sémát.
  
• Alternatív megoldások elvetésének indoklása: Egyszerű txt fájlok is megfelelőek a feladatra, ám a JSON fájltípus által biztosított kulcs-érték adatszerkezet nagy segítséget nyújt a fájl adatbázis szerű átláthatósághoz, illetve a programmal való feldolgozhatósághoz.

Ez a saját téma/nyelvi csomag létrehozásának segítségül is szolgáló leírás.

• A keretrendszer az adatokat .json fájlokban tárolja. Ezek
  • a beállítási adatok (kiválasztott téma illetve nyelv),

Unrestricted adattárolás választott formája

Firebase adatbázis Adatbázis jogosultságai Csak megfelelő ID-val lehet elérni az adatbázist, melyet az alkalmazás tárol. Ezt megfelelően kell tárolni, hogy ne lehessen kinyerni a forráskódból, Az ID csak az áruház adatait tároló adatrészhez kap olvasási jogosultságot. Ehhez létre hoztam egy usert, mely be fog jelentkezni minden kliensen read jogosultsággal:

https://miau.my-x.hu/mediawiki/images/6/6e/FirebaseAuthUser.png

Ez így néz ki a Firebase jogosultság szerkesztőben:

{
 "rules": {
   "quizCatalog": {
     ".read": "auth.uid === 'Létrehozott Firebase Auth user ID-ja'" 
   }
 }
}

ezt egy "FirebaseAPIKey.xcconfig" fájlban tárolom el a következő módon:

EMAIL = "..."
PASSWOWRD = "...."

majd így tárolom el az alkalmazásom 'Info.plist" fájljában:

....
<key>EMAIL</key>
<string>$(EMAIL)</string>
<key>PASSWORD</key>
<string>$(PASSWORD)</string>
....

Bejelnkezni pedig ezzel a metódussal tud az alkalmazás:

if let firebaseEmail = Bundle.main.infoDictionary?["EMAIL"] as? String {
  if let firebasePassword = Bundle.main.infoDictionary?["PASSWOWRD"] as? String {
     Auth.auth().signIn(withEmail: firebaseEmail, password: firebasePassword) { (result, error) in
        if let error = error {
           print("Error signing in: \(error)")
           return
        }
        guard let userId = result?.user.uid else {
           print("No user ID found")
           return
        }
     }
  }
}

Az email és jelszó tárolásátaz alkalmazásban a Config.xcconfig fájl segítségével tudjuk biztonságosan eltárolni.

A probléma ezzel, hogy az ID-t csak új alkalmazás verzó publiklásával tudom módosítani, ám mezei felhasználó nem tud hozzáférni ehhez a kódhoz.

Amennyiben a Config.xcconfig publikussá válik, a usernevet és jelszót is meg kell változtatni, mely egy uj alkalmazasverzio kiadasával élesíthető

Egyéb ötletek Egyszeri jelszóval (OneTimePassword) azonosítsuk a klienst. Ehhez generáltatni kell egy jelszót, melyet el kell tárolni az adatbázisban is valami módon.

Konfiguráció

A rendszer konfigurálható paramétereit json fájlokban tároljuk, melyek a rendszer különböző életciklusaiban kerülnek betöltésre.

Nyelv fájl

A statikus szövvegeket a rendszerben kiválasztott nyelvnek megfelelő fájlból nyeri ki. Támogatott nyelvek: magyar, angol, német. (ChatGPT segítségével több nyelvre is le lehet fordítani, ám lehet nem a legmegfelelőbb módszer, ellenőrizni kell)

"load_file" = "Fájl betöltése";
"start_test" = "Kvíz elkezdése";
"home" = "Kezdőlap";
 "settings" = "Beállítások";
"marketplace" = "Áruház";
"identifier" = "Azonosító (Neptun, Kréta, email stb...)";
"save" = "Mentés";
"json_property_list" = "JSON lista nézet";
"loading" = "Betöltés...";
"file_downloaded" = "Fájl letöltve!";
"done" = "Kész";
"yes"="Igen";
"no"="Nem";
"score"= "Pont táblázat";
"confirm" = "Megerősítés";
"confirm_prompt" = "Biztosan meg akarod szakítani a játékot?";

Tesztadatok

A tesztfolyamat adatok betöltése után lép életbe. Az elérési útvonalnak a publikált képekre kell mutatni.

(kérdés, válasz lehetőségek)

{
"puzzles": [
   {
     "question": "Ide írjuk a kérdést",
     "correctGridOrder": {
       "1": "C:/Users/x/Y/kep1.png",
       "2": "C:/Users/x/Y/kep2.png",
       "3": "C:/Users/x/Y/kep3.png",
       "4": "C:/Users/x/Y/kep4.png",
       "5": "C:/Users/x/Y/kep5.png",
       "6": "C:/Users/x/Y/kep6.png",
       "7": "C:/Users/x/Y/kep7.png",
       "8": "C:/Users/x/Y/kep8.png",
       "9": "C:/Users/x/Y/kep9.png"
     }
   },…
]
}

Esetleges többletadat figyelmen kívül hagyása, ez esetben csak az 1-9ig felsorolt adatokat, és a "question" kulcsban megadott adatokat fogja figyelembe venni a rendszer.

Hibaelhárítás

(note: milyen funkciok vannak amik segitenek a hibaelharitasban)

A log megjelenítése a felhasználónak. Log automatikus kielemzése (pár alap esetet tudok előre definiálni, pl.: rossz json struktura, rossz fajlkiterjesztes stb), és tanács adás a felhasználónak, hogy vajon mi történt, és mit tudna tenni, hogy legközelebb ne történhessen meg ilyen eset. A szoftver kísérletet tehet a hiba automatikus kijavítására ezekben az esetekben:

• hibás .json fájl struktúra -> amennyiben logikus hiba van (hiányzik "," ":" "{" karakter), pótolni tudja azokat. Természetesen tudomást ad a felhasználónak, hogy nem feltétlen a kívánt adat lett előállítva.
• Amennyiben olyan eset áll elő, ami nem pre-definiált, akkor support kontaktálás (email)
• ...

Előredefiniált hibák:

• ...
• ...

Perzisztencia

Egy konfig fájlba vannak írva a külön beállítások (nyelv, téma), tehát ezek perzisztensek. A teszt írása közben készülő, sérülésmentes logfájl segítségével (a teszt tervező engedélyével) vissza lehet állítani a folyamat utoljára elmentett állapotát, akár rendszer újraindulás után is

Tesztelés

Ebben a fejezetben fogom leírni mind a belső (saját magam/KJE-n belüli) mind a külső (.......) tesztelési folyamatokat, észrevételeket, eredményeket.

Belső tesztelés

A keretrendszer megvalósításakor intézményen belüli, és kívüli személyeket felkértünk a tesztelésre. Kiosztott jogosultságokkal belső tesztelés folytatódott intézményen belül, melynek segítségével több hibát is felfedeztünk. privat kanban boardon (majd elkészül)

Github Actions szolgáltatás segítségével minden egyes Branch Merge (vö.: https://www.w3schools.com/git/git_branch_merge.asp?remote=github) alkalmával tesztelendő a kód, ezen és ezen szempontokból (ezek a logikai szempontok, ezekből még nem tudjuk, hogy miket lehet megvalósítani):

• Projekt buildelhetőségének tesztelés:
  • A program le tud futni, nincs benne hiba
  • ...
• Játék játszhatóságának tesztelése
  • Sikerült adatot betölteni
  • Van output a játékból

Nem szempont:

• Tartalmi ellenőrzés

Mivel ez csupán forráskód, ezért nem szükséges a szakdolgozatíró saját magának írt kódot ellenőrizni tartalmi szempontból, hiszen nem publikus

Projekt buildelhetőségének tesztelés

GitHub action fájl: .......

Github Action kód magyarázat

Alap konfiguráció

Ez az alap konfig, még nem a kódot teszteli, hanem megmondja, hogy mit kell/mit nem kell testtelni. a Github Action action neve ......

Forráskód tesztelése

Itt kezdődik a prejekt testz

Játék játszhatóságának tesztelése

Készülnie kell egy Unit tesztelő algoritmusnak, mely tudni fogja a keretrendszerek paramétereit, argumentumjait, és ennek megfelelően megpróbálja mind valid, mind invalid adatokkal feltölteni a keretrendzsert. Ennek eredményeaképpen látni fogjuk, hogy milyen inputra milyen output fog keletkezni, és felfedhetőek lesznek az inkonzisztens adatok által létrehozott hibák is.

Külső tesztelés

Publikus tesztelés, ezen a kanban boardon kell gyűjteni a problémákat a projekttel kapcsolatban: https://github.com/users/SiposPtr/projects/2

Fejlesztői saját 2DM-játékok

Hogyan nézzen ki egy lefejlesztendő játék, amennyiben a fejlesztő kézzel, és nem az erre megadott alrendszert (GTDS) használja.

1. játék

• X=3
  • X1= oszlop1
  • X2= oszlop2
  • X3= oszlop3
• Y=3
  • Y1= sor1
  • Y2= sor2
  • Y3= sor3
• válaszkártyák (9=3*3)
  • VK1= kép1-nek a lokális elérési útvonala
  • VK2= kép2-nek a lokális elérési útvonala
  • VK3= ...
  • VK4= ...
  • VK5= ...
  • VK6= ...
  • VK7= ...
  • VK8= ...
  • VK9= kép9-nek a lokális elérési útvonala
• Maga a feladat megfogalmazása

i. játék

• X>3
• Y>3
• X<>Y

Teszt katalógus

A katalógus a Firebase adatbázist fetcheli, és jeleníti meg.

A katalógus a GTS alrendszer része, mivel:

• a tesztírónak elég egy alkalmazást tudnia használni
• a teszt megírása amúgy is a GTS rendszerben fog történni, így kézenfekvő a kvízek letöltése onnan, ahol a kvízt két-három kattintással később le is lehet játszani

Saját teszt publikálása

https://miau.my-x.hu/mediawiki/index.php/BPROF:2dm_q1

Üzleti hasznosítás

Lényegében iskoláknak készült, hogy a tanulókat számon kérjék stb.................

Kapcsolódó wiki-oldalak

• https://miau.my-x.hu/mediawiki/index.php/Vita:BPROF:2dm
• https://miau.my-x.hu/mediawiki/index.php/BPROF:Csharp_Visszafejt%C3%A9se
• https://miau.my-x.hu/mediawiki/index.php/BPROF:2dm_st%C3%A1tusz
• https://miau.my-x.hu/mediawiki/index.php/BPROF:2dm_q1