Protected Program Executer

--[[
	Protected Execute	   Trystan Cannon
							16 May 2013

	This program allows for users to run other
	programs without the risk of potentially
	malicious functions to execute without their
	allowing so. Currently, this program only
	prevents unauthorized 'fs' and 'os' calls.

	Version: 1.0 Updated 16 May 2013
--]]

-- Variables ------------------------------------
local NATIVE_TERMINAL = term.native -- A reference to the native terminal functions.
_G.screenBuffer	   = {} -- A table containing the visual contents of the screen.

local WARNING_BOX_WIDTH, WARNING_BOX_HEIGHT = 25, 7 -- The width and height of every warning box that is drawn.
local oldFunctions						  = {}
-- Variables ------------------------------------

-- Screen Buffer Functions ------------------------------------
-- Checks if the given color is a valid color on the computer. Returns true or false depending on the aforementioned condition.
local function isColorValid (color)
	for colorIndex, colorValue in pairs (colors) do
		if colorValue == color and type (colorValue) == "number" then
			return true
		end
	end

	return false
end

-- Initializes the global table 'screenBuffer' table to keep track of the screen's contents. Also, this method redirects the terminal
-- to write to the screen buffer and the screen.
local function initScreenBuffer()
	-- Initialize the screen buffer to be an empty canvas of cells whose text color is white and background color is black.
	screenBuffer.currentTextColor	   = colors.white
	screenBuffer.currentBackgroundColor = colors.black

	local screenWidth, screenHeight = term.getSize()
	for height = 1, screenHeight do
		screenBuffer[height] = {}

		for width = 1, screenWidth do
			screenBuffer[height][width] = {text = ' ', textColor = colors.white, backgroundColor = colors.black}
		end
	end

	-- Create a new terminal table which will have all of the native functions with some edited functionality.
	local terminal = {}
	for functionName, functionObject in pairs (NATIVE_TERMINAL) do
		terminal[functionName] = functionObject
	end

	-- Overrides the term.write method to write to the screen buffer and the screen.
	terminal.write = function (text)
		local cursorX, cursorY = term.getCursorPos()

		if cursorX < 1 or cursorX > screenWidth or cursorY < 1 or cursorY > screenHeight then
			return NATIVE_TERMINAL.write (text)
		end

		for charIndex = 1, text:len() do
			screenBuffer[cursorY][cursorX].text			= text:sub (charIndex, charIndex)
			screenBuffer[cursorY][cursorX].textColor	   = screenBuffer.currentTextColor
			screenBuffer[cursorY][cursorX].backgroundColor = screenBuffer.currentBackgroundColor
			cursorX = cursorX + 1

			if cursorX > screenWidth then
				break
			end
		end

		return NATIVE_TERMINAL.write (text)
	end

	-- Overrides the term.setTextColor method to set the current text color of the screen buffer and the terminal.
	terminal.setTextColor = function (textColor)
		if isColorValid (textColor) then
			screenBuffer.currentTextColor = textColor
		end

		return NATIVE_TERMINAL.setTextColor (textColor)
	end

	-- Overrides the term.setBackgroundColor method to set the current background color of the screen buffer and the terminal.
	terminal.setBackgroundColor = function (backgroundColor)
		if isColorValid (backgroundColor) then
			screenBuffer.currentBackgroundColor = backgroundColor
		end

		return NATIVE_TERMINAL.setBackgroundColor (backgroundColor)
	end

	-- Overrides the term.clear method to clear out the entire buffer and the terminal.
	terminal.clear = function()
		for line = 1, screenHeight do
			for width = 1, screenWidth do
				local cell = screenBuffer[line][width]

				cell.text			= ' '
				cell.textColor	   = screenBuffer.currentTextColor
				cell.backgroundColor = screenBuffer.currentBackgroundColor
			end
		end

		return NATIVE_TERMINAL.clear()
	end

	-- Overrides the term.clearLine method to clear out only the current line in the buffer and terminal.
	terminal.cearLine = function()
		local _, currentLine = term.getCursorPos()

		if currentLine > 0 and currentLine <= screenHeight then
			for width = 1, screenWidth do
				local cell = screenBuffer[currentLine][width]

				cell.text			= ' '
				cell.textColor	   = screenBuffer.currentTextColor
				cell.backgroundColor = screenBuffer.currentBackgroundColor
			end
		end

		return NATIVE_TERMINAL.clearLine()
	end

	term.redirect (terminal)
end

-- Kills the screen buffer by emptying the buffer and restoring the terminal to its native functionality.
local function killScreenBuffer()
	screenBuffer = {}
	term.redirect (NATIVE_TERMINAL)
end
-- Screen Buffer Functions ------------------------------------

-- Anti Virus Functions ------------------------------------
-- Prompts the user if a program being executed is trying to execute a malicious function. The user
-- will be asked if they want the program to be allowed to execute the function. However, if the user says
-- no, then the program might not work properly. Returns true or false depending on the Y/N value of the
-- user's input.
local function promptUserOfMaliciousFunctionCall (functionName)
	local cursorX, cursorY		  = term.getCursorPos()
	local screenWidth, screenHeight = term.getSize()
	local MAX_MESSAGE_WIDTH		 = WARNING_BOX_WIDTH - 4

	-- Draws a string in the center of the screen.
	local function drawCentered (myString, line)
		term.setCursorPos (screenWidth / 2 - myString:len() / 2, line)
		NATIVE_TERMINAL.write (myString)
	end

	-- Draw a simple black and white box in the middle of the screen which describes the situation.
	local currentTextColor, currentBackgroundColor = screenBuffer.currentTextColor, screenBuffer.currentBackgroundColor
	term.setTextColor (colors.white)
	term.setBackgroundColor (colors.black)

	drawCentered ('+' .. string.rep ('-', WARNING_BOX_WIDTH - 2) .. '+', screenHeight / 2 - WARNING_BOX_HEIGHT / 2)
	for line = 1, WARNING_BOX_HEIGHT do
		drawCentered ('|' .. string.rep (' ', WARNING_BOX_WIDTH - 2) .. '|', line + screenHeight / 2 - WARNING_BOX_HEIGHT / 2)
	end
	drawCentered ('+' .. string.rep ('-', WARNING_BOX_WIDTH - 2) .. '+', screenHeight / 2 + WARNING_BOX_HEIGHT / 2)

	drawCentered ("Malicious call:", screenHeight / 2 - WARNING_BOX_HEIGHT / 2 + 1)
	drawCentered (functionName:sub (1, MAX_MESSAGE_WIDTH), screenHeight / 2 - WARNING_BOX_HEIGHT / 2 + 3)
	drawCentered ("Allow call? Y \\ N?", screenHeight / 2 - WARNING_BOX_HEIGHT / 2 + 5)

	-- Wait for the user to press 'Y' or 'N' signaling their answer.
	local char = nil
	while not (char == 'y' or char == 'n') do
		_, char = oldFunctions.os.pullEvent ("char")
	end

	-- Restore the screen to the way it was.
	for lineNumber = 1, screenHeight do
		for cellNumber = 1, screenWidth do
			local cell = screenBuffer[lineNumber][cellNumber]

			NATIVE_TERMINAL.setTextColor (cell.textColor)
			NATIVE_TERMINAL.setBackgroundColor (cell.backgroundColor)
			NATIVE_TERMINAL.setCursorPos (cellNumber, lineNumber)
			NATIVE_TERMINAL.write (cell.text)
		end
	end
	NATIVE_TERMINAL.setCursorPos (cursorX, cursorY)
	NATIVE_TERMINAL.setTextColor (screenBuffer.currentTextColor)
	NATIVE_TERMINAL.setBackgroundColor (screenBuffer.currentBackgroundColor)

	return char == 'y'
end

-- Secures all of the functions in the APIs specified in 'maliciousAPIs' to prompt the user if they want to allow some program to execute
-- a potentially malicious function.
-- Returns all of the old functions in a table.
local function secureMaliciousAPIs()
	local oldFunctions = {}

	-- Secure the os API.
	oldFunctions.os = {}
	for functionName, functionObject in pairs (os) do
		oldFunctions.os[functionName] = functionObject

		os[functionName] = function (...)
			if promptUserOfMaliciousFunctionCall ("os." .. functionName) then
				return oldFunctions.os[functionName] (...)
			else
				return nil
			end
		end
	end

	-- Clean up the exceptions for the os API.
	os.startTimer   = oldFunctions.os.startTimer
	os.pullEvent	= oldFunctions.os.pullEvent
	os.pullEventRaw = oldFunctions.os.pullEventRaw

	-- Secure the fs API.
	oldFunctions.fs = {}
	for functionName, functionObject in pairs (fs) do
		oldFunctions.fs[functionName] = functionObject

		fs[functionName] = function (...)
			if promptUserOfMaliciousFunctionCall ("fs." .. functionName) then
				return oldFunctions.fs[functionName] (...)
			else
				return nil
			end
		end
	end

	-- Clean up the exceptions for the fs API.
	fs.isDir	  = oldFunctions.fs.isDir
	fs.exists	 = oldFunctions.fs.exists
	fs.combine	= oldFunctions.fs.combine
	fs.getName	= oldFunctions.fs.getName
	fs.list	   = oldFunctions.fs.list
	fs.isReadOnly = oldFunctions.fs.isReadOnly

	return oldFunctions
end

-- Restores all of the secured APIs to their previous states given a table containing the states of all of the malicious APIs.
local function restoreMaliciousAPIs (oldFunctions)
	for apiName, api in pairs (oldFunctions) do
		for functionName, functionObject in pairs (api) do
			local currentEnvironment = getfenv (1)

			if _G[apiName] ~= nil then
				_G[apiName][functionName] = functionObject
			elseif currentEnvironment[apiName] ~= nil then
				currentEnvironment[apiName][functionName] = functionObject
			end
		end
	end
end
-- Anti Virus Functions ------------------------------------

-- Get the potential file path that we need to check for malicious calls. If there wasn't a valid file path then print the program usage instructions.
local tArgs	   = { ... }
local path		= (tArgs[1] ~= nil) and shell.resolve (tArgs[1]) or ""
local currentPath = shell.resolve (shell.getRunningProgram())

if path ~= currentPath and fs.exists (path) and not fs.isDir (path) then
	initScreenBuffer()
	oldFunctions = secureMaliciousAPIs()

	local success, errorMessage = pcall (dofile, path)
	restoreMaliciousAPIs (oldFunctions)
	killScreenBuffer()
else
	print ("Usage: " .. fs.getName (currentPath) .. " <filePath>.")
end

superaxander, on 19 May 2013 - 04:28 AM said:

That was definatly not to get my post count up but just to say I like it. Why be so harsh if I give you a compliment?