Starta Android-appen från din telefon. Genomgång av verktyg för att starta och felsöka applikationer på Android. Aktivera USB-felsökning

Sandlåda

Tjenare Gud 18 september 2011 klockan 15:55

Översikt över verktyg för att starta och felsöka applikationer på Android

• Timmerrum *

När jag utvecklade min första Android-applikation stötte jag på problemet med att starta applikationen för testning och felsökning. Den här artikeln bör hjälpa en nybörjare att välja ett emuleringsverktyg.

Android virtuell enhet (AVD)

Installation:
Detta emuleringsverktyg är inbyggt i Android SDK.

Miljö:
(med ett exempel på användning i Eclipse)
Fönster > Android SDK och AVD Manager > Nytt
Vi anger namnet på den virtuella enheten, plattformen, minneskortstorleken, visningstyp...
Klicka på Skapa AVD.

Lansera:
Den första lanseringen av emulatorn tar väldigt lång tid, särskilt på svaga enheter. Till exempel kunde jag inte vänta på den första lanseringen på min netbook, och när jag lanserade den för första gången på min dator var jag säker på att emulatorn hade gått in i en evig loop.
Efterföljande lanseringar av emulatorn kommer att vara lite snabbare.
Tiden mellan att trycka på "Kör"-knappen och uppkomsten av huvudaktiviteten för testapplikationen på emulatorn tar i genomsnitt 11 sekunder. Mätningarna utfördes på en ganska kraftfull dator.

Fördelar och nackdelar:
+ möjligheten att testa applikationen på olika versioner av Android OS, på enheter med olika skärmtyper...
+ olika inställningar som är nödvändiga för att testa, till exempel att ändra skärmorienteringen
+ SD-kortemulering
- en lång tid mellan att trycka på "Kör"-knappen och starta programmet på emulatorn
- emulatorn fungerar mycket långsamt, till exempel vad telefonen bearbetade på 1-2 sekunder, gjorde emulatorn på 8-10 sekunder

VirtualBox+Android x86

Installation och konfiguration:

1. Ladda ner och installera VirtualBox.
2. Ladda ner bilden.
3. "Vi skapar en Linux 2.6/Other Linux virtuell maskin, 512 Mb RAM, Bridged Network, HD 2 Gb, Disable Mouse Integration. Vi ansluter ISO-filen och startar in i ett av LiveCD-alternativen (det finns HDPI- och MDPI-alternativ)” eller följ dessa instruktioner.
4. Tryck på Alt-F1 för att gå ut till konsolen och skriv netcfg och kom ihåg emulatorns IP-adress. För att återgå till GUI, tryck Alt-F7.
5. adb ansluta

Lansera:
Jag registrerade inte tiden mellan att trycka på "Kör" -knappen och utseendet på huvudaktiviteten för testapplikationen på emulatorn, men enligt subjektiva känslor händer detta nästan omedelbart.

Fördelar och nackdelar:
+ en kort tidsperiod mellan att trycka på "Kör"-knappen och att starta programmet på emulatorn
+ snabbt arbete på ställen
- ganska lång och ibland problematisk installation
- emulatorn är långsam på vissa ställen, det finns problem med bilden (särskilt på MDPI)
- problem med SD-kortemulering, ändra skärmorientering,...
- endast två (tre) versioner av Android OS tillgängliga och endast två skärmtyper tillgängliga

Android-telefon ansluten via USB

Installation och konfiguration:

1. Vi aktiverar felsökningsläget på telefonen. (Inställningar > Applikationer > Utveckling > USB-felsökning).
2. Ladda ner drivrutinen för din telefon.
3. Vi ansluter telefonen till datorn.
4. Installera drivrutiner. Avsnittet ADB-gränssnitt bör visas i Enhetshanteraren.
5. adb-enheter. Om din telefon inte visas i listan installerar du om ADB-drivrutinen.

Lansera:
Det går cirka 5 sekunder mellan att trycka på "Kör"-knappen och huvudaktiviteten för testapplikationen visas på telefonen.

Fördelar och nackdelar:
+ möjligheten att se applikationen som användaren kommer att se den (en mycket viktig punkt, särskilt när du skapar gränssnittet och designen av applikationen)
+ multitouch (om din telefon har det)
+ ändra skärmorientering, accelerometer (om din telefon har det)
- endast en OS-version och en skärmtyp
- ett annat objekt kommer att visas på det fysiska skrivbordet

Slutsatser:

Jag försökte arbeta med vart och ett av dessa emuleringsverktyg och bestämde mig för det här alternativet:
1. skriva och testa en applikation med en telefon;
2. testa applikationen på flera virtuella Android-enheter med olika kombinationer av OS-version och skärmtyp.
Jag hoppas att läsaren har valt en emulator eller lärt sig något nytt själv.
Lycka till med ditt test!

Dekompilering och felsökning av Android-applikationer

Alexander Antipov

Den här artikeln kommer att visa dig hur du ansluter en debugger till en Android-applikation och går igenom metoderna som anropas med hjälp av informationen som erhålls efter dekompilering av applikationen.

Den här artikeln kommer att visa dig hur du ansluter en debugger till en Android-applikation och går igenom metoderna som anropas med hjälp av informationen som erhålls efter dekompilering av applikationen. Den goda nyheten är att felsökning inte kräver superanvändarprivilegier. De beskrivna teknikerna kan vara mycket användbara under pentests. mobila applikationer, eftersom vi kan "infiltrera" koden medan programmet körs, hämta och registrera information som vi normalt inte skulle ha tillgång till. Du kan till exempel fånga upp trafik före kryptering och få nycklar, lösenord och all annan värdefull information i farten. Artikeln kommer att vara användbar för pentestare och mobilapplikationsutvecklare som vill få mer djupgående kunskap om möjliga attacker på Android-plattformen.

Testmiljökrav:

• Operativsystem: Windows / Mac OS X / Linux
• Java (version 1.7 rekommenderas)
• IDE (Eclipse, IntelliJ IDEA, Android Studio)
• Android SDK (https://developer.android.com/sdk/index.html?hl=i)
• APKTool (https://code.google.com/p/android-apktool/)/APK Studio (http://apkstudio.codeplex.com)
• Android-enhet/emulator

Följande konfiguration kommer att användas i den här artikeln: Windows 8, Android Studio och IntelliJ IDEA. Enhet: Nexus 4 med Android-versioner 4.4.4. Jag rekommenderar att du lägger till alla verktyg i miljövariabeln PATH för att göra åtkomsten till dessa verktyg enklare och snabbare.

Android-applikationspaketet (APK) som används i den här artikeln kan laddas ner här: com.netspi.egruber.test.apk .

Enhetskonfiguration

Instruktionerna nedan hjälper dig att förbereda enheten för experiment.

Aktivera avsnittet Utvecklaralternativ

Till att börja med måste USB-felsökning vara aktiverad på din Android-enhet (USB-felsökningsalternativ), vilket gör att du kan "kommunicera" med enheten med hjälp av verktyg från Android SDK. Men innan detta måste du aktivera avsnittet Utvecklaralternativ. På din enhet går du till avsnittet Inställningar > Om telefon och klickar på objektet Byggnummer flera gånger, varefter ett meddelande ska visas om att avsnittet Utvecklaralternativ är aktiverat.

Figur 1: För att aktivera avsnittet Utvecklaralternativ måste du klicka på Byggnummer flera gånger

Aktivera USB-felsökning

För att aktivera felsökning via USB-porten, gå till Inställningar > Utvecklaralternativ och markera rutan bredvid USB-felsökning.

Figur 2: Aktivera USB-felsökningsalternativet

Ansluter enheten och startar ADB

Efter att ha anslutit enheten till datorn via en USB-port ska meddelandet "USB-felsökning ansluten på enheten" visas. Du bör också kontrollera om du kan ansluta till din enhet med appen Android Debug Bridge (ADB) som ingår i Android SDK (Android SDK Platform-tools). Vid kommandotolken anger du följande kommando:

Enheten bör visas i listan.

Figur 3: Lista över anslutna enheter

Om enheten inte visas i listan, kommer de flesta trolig orsak i felaktigt installerade drivrutiner(på Windows). Beroende på enhet kan drivrutinen hittas antingen i Android SDK eller på tillverkarens webbplats.

Kontrollerar applikationen för felsökning

Innan du felsöker Android-applikationer måste du först kontrollera om detta är möjligt. Kontrollen kan utföras på flera sätt.

Det första sättet är att springa Android-enhetsövervakning, ingår i Android SDK (i verktygsmappen). I Windows-fil kallas monitor.bat. På öppna Android Enhetsövervakning Enheten kommer att visas i avsnittet Enheter.

Figur 4: Applikation för Android Device Monitor

Om någon applikation på enheten kan felsökas, kommer den applikationen också att visas i listan. Jag skapade ett testprogram, men listan är tom eftersom programmet inte kan felsökas.

Det andra sättet att kontrollera om en applikation är felsökningsbar är att undersöka filen AndroidManifest.xml från applikationspaketet (APK, Android applikationspaket). APK är ett zip-arkiv som innehåller all information som behövs för att köra applikationen på din Android-enhet.

Närhelst en applikation laddas från Google Play Store, applikationspaketet laddas också ner. Alla nedladdade APK-filer lagras vanligtvis på enheten i mappen /data/app. Om du inte har superanvändarrättigheter kommer du inte att kunna lista filer från /data/app-katalogen. Även om du känner till namnet på APK-filen kan du kopiera den med hjälp av verktyget adb. För att ta reda på namnet på APK-filen, skriv in följande kommando:

Kommer komma kommandorad enheter. Skriv sedan in följande kommando:

pm list paket -f

En lista över alla paket på enheten visas.

Figur 5: Lista över paket på enheten

Tittar vi på listan hittar vi en testapplikation.

Figur 6: Skapat testapplikationspaket (markerat i vitt)

Nu måste du kopiera paketfilen. Öppna skalet och skriv in följande kommando:

adb pull /data/app/[.apk-fil]

Figur 7: Kopiera APK-filen från enheten till systemet

Nu måste du öppna paketfilen och undersöka innehållet i AndroidManifest.xml. Tyvärr kan vi inte bara extrahera arkivet eftersom APK-filen är kodad i binärt format. Det verktyg som oftast används för avkodning är apktool fast jag använder APK Studio, eftersom denna applikation har ett vänligt grafiskt gränssnitt. Resten av artikeln kommer att prata om APK Studio.

I APK Studio, klicka på den lilla gröna ikonen, namnge projektet och ange sökvägen till APK-filen. Ange sedan let för att spara projektet.

Figur 8: Skapa ett nytt projekt i APK Studio

När du har öppnat APK-filen väljer du filen AndroidManifest.xml och tittar på inställningarna för applikationstaggen. Om android:debuggable-flaggan saknas (eller finns men inställd på false), kan programmet inte felsökas.

Figur 9: Innehållet i filen AndroidManifest.xml

Ändra filen AndroidManifest.xml

Med hjälp av apktool-verktyget eller APK Studio kan vi modifiera filerna och packa tillbaka innehållet i paketet. Vi kommer nu att modifiera filen AndroidManifest.xml så att applikationen kan felsökas. Lägg till raden android:debuggable="true" inuti programtaggen.

Figur 10: Ändra innehållet i applikationstaggen

När du har lagt till flaggan klickar du på "hammare"-ikonen och sätter ihop paketet igen. Det ombyggda paketet kommer att finnas i build/apk-katalogen.

Figur 11: Återuppbyggnaden av paketet slutförts framgångsrikt

Efter ombyggnaden signeras paketet och kan installeras om på enheten (alla Android-applikationer måste vara signerade). De flesta applikationer verifierar inte certifikatet som används för att signera. Annars måste du ändra koden som utför denna kontroll.

Nu måste du installera det ombyggda paketet. Ta först bort det gamla programmet med följande kommando:

adb pm avinstallera

Installera sedan det nya paketet:

adb installera [.apk-fil]

Du kan också ta bort och installera paketet med ett kommando:

adb installation -r [.apk-fil]

Figur 12: Installation av det ombyggda paketet

Kontrollera att det ominstallerade programmet startar korrekt på enheten. Om allt fungerar, gå tillbaka till Android Device Monitor, där testapplikationen ska visas.

Figur 13: Den ombyggda applikationen kan nu felsökas

Konfigurera utvecklingsmiljön (IDE)

Nu kan du koppla en debugger till den ombyggda applikationen, men först måste du skapa ett projekt i utvecklingsmiljön (artikeln använder IntelliJ IDEA). Låt oss skapa ett nytt projekt. I fältet Programnamn anger du ett anpassat namn. I fältet Paketnamn anger du ett namn som exakt matchar mapphierarkin för det ombyggda paketet.

Figur 14: Skapa ett nytt projekt i IntelliJ IDEA

Vanligtvis matchar APK-filnamnet mappstrukturen, men om du är osäker, kontrollera kataloghierarkin i APK Studio ner till mappen där programfilerna finns. I mitt fall är namnet och mappstrukturen exakt samma (com.netspi.egruber.test).

Figur 15: Testa applikationskataloghierarkin

Avmarkera "Create Hello World Activity" och avsluta med att skapa projektet (alla andra alternativ förblir standard). Det nya projektet ska se ut ungefär så här:

Figur 16: Hierarki av mappar och filer i det nya projektet

Efter att ha skapat projektet måste du lägga till källkoden från APK-filen så att debuggern "vet" namnen på symboler, metoder, variabler etc. Den goda nyheten är att Android-applikationer kan dekompileras nästan utan kvalitetsförlust (källkoden kommer att vara densamma som originalet). Efter dekompileringen importeras källkoden till utvecklingsmiljön (IDE).

Hämta källor från ett applikationspaket

Först måste du konvertera APK-filen till en jar-fil. Sedan, med hjälp av en java-dekompilator, får vi källkoden för applikationen. Vi kommer att göra omvandlingen till burk med hjälp av verktyget dex2jar. dex2jar har en d2j-dex2jar.bat-fil som används för att konvertera APK till jar. Kommandosyntaxen är ganska enkel:

d2j-dex2jar.bat [.apk-fil]

Figur 17: Konvertera APK till jar

Öppna eller dra sedan den resulterande filen till JD-GUI (detta är en java-dekompilator).

Figur 18: Jarfilstruktur

Jar-filen ska visas som en hierarkisk struktur som innehåller java-filer med läsbar källkod. Gå till Arkiv > Spara alla källor för att packa alla källor i ett zip-arkiv.

Figur 19: Spara källtexterna för den dekompilerade filen

När du har sparat källtexterna packar du upp arkivet i en separat katalog.

Bild 20: Uppackat arkiv

Nu måste du importera båda katalogerna till det tidigare skapade projektet i IDE. I IntelliJ, gå till src-mappen och kopiera innehållet i det uppackade arkivet där (två kataloger).

Figur 21: Båda mapparna kopieras till src-katalogen

När vi återvänder till Intellij ser vi det uppdaterade projektet.

Figur 22: Källtexter förekom i projektet

Om vi ​​klickar på något element i listan ser vi källtexten. Som du kan se i skärmdumpen nedan (källtexten för LoginActivity-klassen), är källkoden obfuskerad med ProGuard.

Figur 23: Obfuskerad källtext för klassen LoginActivity

Ansluter en debugger

Nu när projektet har källkod kan vi börja sätta brytpunkter på metoder och variabler. När brytpunkter nås kommer applikationen att stoppas. Som ett exempel satte jag en brytpunkt på en metod (till höger i den obfuskerade koden) som ansvarar för att bearbeta information som skrivs in i ett textfält.

Figur 24: En brytpunkt ställs in på en obfuskerad metod.

Så snart brytpunkten visas ansluter du felsökaren till processen på enheten genom att klicka på skärmikonen i det övre högra hörnet (ikonen kan skilja sig åt på din IDE).

Figur 25: Ansluta debuggern till processen

Figur 26: Lista över processer för att ansluta en debugger

Efter att ha valt processen kommer debuggern att ansluta till enheten.

Figur 27: Debugger kopplad till en process som körs på enheten

Jag kommer att skriva in siffran 42 i textfältet (om du kommer ihåg finns det en brytpunkt på motsvarande metod).

Figur 28: Ange siffran 42 i textfältet

Efter att ha tryckt på knappen Enter Code kommer applikationen att gå sönder vid brytpunkten eftersom felsökaren är medveten om vilken metod som anropas på enheten. En kompilerad Android-applikation innehåller felsökningsinformation (som variabelnamn) som är tillgänglig för alla Java Debug Wire Protocol (JDWP)-kompatibla debuggers. Om din applikation har felsökning aktiverad, kommer en JDWP-kompatibel debugger (de flesta felsökare som ingår i Java-utvecklingsmiljöer faller inom denna kategori) att kunna ansluta till virtuell maskin Android-applikationer och sedan läsa och köra felsökningskommandon.

Figur 29: Brytpunktsträff

Skärmdumpen nedan visar numret som vi tidigare angav i textfältet.

Figur 30: Lista över variabler för den aktuella klassinstansen

Slutsats

Vi kan inte bara läsa data i applikationen, utan även infoga vår egen. Detta kan vara användbart om vi till exempel vill avbryta flödet av kodexekvering och kringgå vissa delar av algoritmen. Med hjälp av en debugger kan vi bättre förstå applikationens logik och analysera vad som är otillgängligt för den genomsnittliga användaren. Till exempel kan det vara till stor hjälp att se de krypteringsfunktioner som används och dynamiska nycklar. Ibland vid felsökning är det också användbart att veta hur funktioner interagerar med filsystem eller en databas för att förstå vilken information som lagras av applikationen. Liknande manipulationer är tillgängliga på alla Android-enheter utan superanvändarprivilegier.

Senaste uppdatering: 03/09/2017

Standardprojektet som skapades i föregående avsnitt innehåller redan en del funktionalitet. Det är sant att den här funktionen gör nästan ingenting, den visar bara strängen "Hello world!" på skärmen.

I studio bör filen activity_main.xml vara öppen som standard, som innehåller definitionen GUI applikationer.

Om filen öppnas i designerläge och applikationsdesignen visas i Android Studio-centret, måste vi byta filvyn till text. För att byta läge - från text till grafik och tillbaka igen, finns det två knappar längst ner, Design och Text.

Låt oss nu ändra applikationskoden så att den visar strängen "Hej Android" på skärmen. För att göra detta, låt oss ändra koden i filen activity_main.xml, som nu ser ut ungefär så här:

Låt oss ändra definitionen av TextView-elementet i den här filen, som är ansvarig för att visa textinformation på skärmen på en mobil enhet. Själva utdatatexten anges med android:text-attributet. Låt oss därför ändra all kod i filen activity_main.xml enligt följande:

Efter att ha sparat filen kan vi byta till den grafiska vyn och se att den grafiska designern automatiskt kommer att uppdatera och visa raden vi just definierat.

Utvecklarläge på telefonen

Vi kan använda emulatorer eller riktiga enheter för att köra och testa applikationen. Men helst är det bättre att testa på riktiga enheter.

För att använda en mobil enhet för att testa på en fungerande maskin måste du installera en drivrutin. Om din Google-smarttelefon är Nexus 5/6/5x/6P eller Google Pixel, måste du för att stödja den installera Google Usb Driver-paketet via SDK Manager. Om enhetstillverkaren är en annan leverantör måste du installera USB-drivrutinen som tillhandahålls av denna leverantör. Om operativsystemet är Windows 10, kan systemet som regel hitta drivrutinen genom uppdateringscentret och installera den.

Som standard är utvecklaralternativ på smartphones dolda. För att göra dem tillgängliga måste du gå till Inställningar > Om telefonen och tryck sju gånger Bygga nummer.

Gå tillbaka till föregående skärm och där ser du ett tillgängligt alternativ Utvecklaralternativ (för utvecklare).

Låt oss gå vidare till punkten För utvecklare och aktivera USB-felsökning:

Startar applikationen

Låt oss ansluta en enhet med Android OS (om vi testar på en riktig enhet) och starta projektet genom att klicka på den gröna pilen i verktygsfältet.

Sedan börjar bygget av projektet. Denna process kan ta lite tid, varefter en dialogruta visas för att välja en enhet att starta. Här kan vi välja en gadget ansluten till datorn eller en emulator:

Välj enheten och klicka på OK-knappen. Och efter lanseringen kommer vi att se vår applikation på enhetens skärm.

De grundläggande stegen för att skapa en Android-emulator för att testa de skapade applikationerna visades. Att använda en emulator är naturligtvis ganska bekvämt, men bara om du har en ganska kraftfull dator och att ladda ner emulatorn, såväl som dess funktion, tar inte mycket tid. Men alla har inte turen att ha sådana monstermaskiner, så i den här artikeln kommer jag att prata om ett ganska bra sätt att testa ditt arbete i Android Studio med en riktig ansluten enhet.

Den här artikeln kommer att passa dig i två huvudfall:

1) Din dator är inte tillräckligt kraftfull för att köra emulatorn snabbt (oavsett om det är i Android Studio eller Eclipce);

2) Du har en gammal liggande Android-smarttelefon och du vet inte var du ska lägga den (det är synd att ge bort/slänga det).

Det är också värt att notera att den här metoden också kan vara användbar för ägare av högpresterande datorer, för att testa på en emulator är en sak, men att se applikationen fungera på en riktig smartphone är en helt annan.

Så för att ansluta din smartphone till Android Studio måste du först installera den nödvändiga uppsättningen drivrutiner. Som regel leder det ofta till ingenting att kämpa med en standarduppsättning drivrutiner, så jag rekommenderar att du laddar ner den här filen omedelbart (var inte orolig, det är inte ett virus, även om antiviruset klagar) och efter att tidigare ha tagit bort de gamla drivrutinerna , installera den här filen (under installationen, telefonen Det är bättre att inte ansluta).

När du har installerat drivrutinerna, anslut din enhet till din dator via USB. Alla nödvändiga inställningar kommer att startas och installeras automatiskt.

Starta sedan Android Studio. Låt oss gå till Verktyg ---Android och markera rutan bredvid "Aktivera ADB-integration" (ADB - Android Debug Bridge). Efter detta måste du konfigurera Android Studio så att när du klickar på den gröna "Kör"-knappen installeras din applikation omedelbart och startas på den anslutna smartphonen. Låt oss gå till Run ---Redigera Konfigurationer. Följande fönster visas:

och i "Target Device"-blocket, markera rutan "USB Device" och klicka på OK.

Det var allt, grattis, om du gjorde allt korrekt identifierade drivrutinerna din enhet, och när du klickar på applikationsstartknappen (markerad i rött):

applikationen kommer att installeras och köras på den anslutna enheten.

Efter det är allt du behöver göra att plocka upp den anslutna enheten och testa ditt programmeringsarbete.

Det är värt att notera att om applikationen är installerad, men inte startar automatiskt, så betyder det troligen att det finns ett fel någonstans i applikationen (även om det kanske inte är markerat i Android Studio, till exempel en viktig kodbit saknas helt enkelt).

Jag hoppas att den här artikeln är användbar för dig. Lycka till i dina ansträngningar!