Topic:  Cloud Security (based on content from Chapter 6 in Cloud Computing: Concepts, Technology & Architecture)

Overview:  The diagram provided in the assignment rubric illustrates interaction between two cloud service consumers (A and B) and two virtual servers (A and B) hosted on a cloud.

Based on the limited information provided in the depicted scenario, describe three types of attacks that could potentially be carried out if any of the programs outside of the cloud were malicious.

Provide a brief explanation justifying the threat of each proposed attack. For each of the three types of attacks, please list and describe a potential cause.

Please ensure you refer to the attached document for details on the requirements for this assignment!

2 ) Discussion: 

In your initial post, discuss the differences between Virtualization and Cloud Computing.

Please find one organization that has recently adopted virtualization and summarize their reasons for taking this approach. What challenges did they face?

minimum of 500 words.

Displaying Accounts and Transactions in the Banking System

Expand the Banking System from Lab 2 to display accounts and transactions.

Perform the following.

1. After a successful Login, develop the elements to display a list of accounts for the user.

2. Provide the ability for the user to select an account to display.

3. Develop the elements for displaying the transactions for the selected account. Display the running balance for the account.

When completed, place the project file into a zip file and submit it to Canvas.

(Using Lab1 source code we need to create all the above functionalities in Lab3 and code need to be without errors and operational).

Lab #1 — Building a Calculator

Your task for Lab #1 is to build a calculator in Java that has two modes, controllable by command-line options postfix and infix. In both modes the calculator will read lines of input from standard input. For each input line, the calculator will evaluate the expression that was input and print the result on a separate line. The program ends when it encounters the EOF character,similar to the behavior of most Unix utilities.

To simplify matters regarding dealing with different types of numbers, in this assignment, all numbers are to be represented internally as either Java floatprimitives or Floatobjects depending on your implementation choices.

Your calculator will implement the following operations:

• +, -, *, /
• ^ (exponentiation: e.g., 2^3 = 8).

Your calculator will implement expressions containing either a sole number or operations applied to numbers.

Mode #1 — Postfix Notation

The first mode that you will implement is one where the calculator accepts anexpression that is expressed in postfix notation. For those of you familiar with HP’s line of scientific and graphing calculators, postfix notation is also known as RPN or Reverse Polish Notation, in honor of the Polish logician Jan Łukasiewicz who invented Polish notation, also known as prefix notation.

Here are examples of expressions written in postfix notation with their conversions to infix notation and their evaluations:

2 3 +

2 + 3

5

2 3 + 5 *

(2 + 3) * 5

25

2 3 5 * +

2 + (3 * 5)

17

2 3 2 ^ * -10 –

2 * (3 ^ 2) – -10

28

How an RPN calculator works internally is as follows: it maintains an internal stack that is used to store operands and intermediate results. Let’s use the expression “4 3 + 5 *” as an example. The first thing that we do is lexical analysis on the input string by first splitting the string by its whitespace characters and then performing the proper type conversions on the numbers, resulting in a list that looks like this:

[4.0, 3.0, “+”, 5.0, “*”]

Next, we iterate through the list. For each number, we push it onto the stack. Once we reach an operator on the list, we pop the stack twice, perform that operation on the popped numbers, and then push the result onto the stack. In this example, the elements 3.0 and 4.0 are popped from the stack. We then perform the “+” operation on the second and first elements popped from the stack (order matters for “-”, “/”, and “^”), and then push the result (12.0) onto the stack. Then, as we continue iterating through the list, we encounter 5.0, and thus we push it on the stack, resulting in a stack with the elements 12.0 (bottom) and 5.0 (top). Finally, the last token in the list is “*”, and so we pop the stack twice, multiplying 5.0 and 12.0 to get 60.0, and then we push it back on the stack.

When we have exhausted the list of tokens, we pop the stack and print the popped value as the result of the expression.

One of the nice properties of postfix notion is the lack of a need to specify operator precedence. It is this property that makes it possible to implement an RPN calculator without the need for specify a formal grammar for expressions. In fact, there are full-fledged programming languages such as Forth and PostScript that use postfix notation and rely on a stack.

Mode #2 — Infix Notation

Unlike a postfix calculator where parsing is a very straightforward task, parsing is not as straightforward in infix notation, since you have to concern yourself with expressions of arbitrary length and operator precedence. Your calculator will have to properly implement the PEMDAS (parentheses, exponents, multiplication, division, addition, subtraction) order of operations that are from elementary algebra.

Thankfully with the help of parser generators such as ANTLR, you won’t have to deal with the labor of implementing parsing algorithms.

Here is an excellent tutorial for using ANTLR:https://tomassetti.me/antlr-mega-tutorial/ (Links to an external site.). Please also refer to the main ANTLR website athttps://www.antlr.org (Links to an external site.).

Your goals are the following:

1. Write a BNF or EBNF grammar that is able to represent expressions in infix notation that is also able to implement the PEMDAS order of operations.
2. Express that grammar as an ANTLR grammar.
3. Use ANTLR to generate an abstract syntax tree.
4. Traverse the abstract syntax tree to evaluate the expression. There are two ways of doing this: (1) either evaluating the abstract syntax tree directly, or (2) using the AST to generate a postfix notation representation of the expression, and then evaluating it as in Mode #1.

Some Examples:

$ java Calculator postfix

Calculator> 2 4 * 2 ^ 10 –

54

Calculator> 5

5

Calculator> 8 24 + 9 –

23

$ java Calculator infix

Calculator> (2 * 4)^2 – 10

54

Calculator> 5

5

Calculator> 8 + 24 – 9

23

Deliverable:

A collection of Java and ANTLR source code files in a *.zip archive, where the main method is located in a class called Calculator and in a file called Calculator.java.

Grading Rubric:

Mode #1 (Postfix Notation): 30%

Mode #2 (Infix Notation Grammar and Parsing): 50%

Mode #2 (Infix Notation Evaluation): 20%

Note:Your code must compile in order for it to receive any credit; any submission that does not compile will receive a grade of 0%.

Part of lab lesson 8

There are two parts to lab lesson 8. The entire lab will be worth 100 points.

Lab lesson 8 part 2 is worth 50 points

For part 2 you will have 40 points if you enter the program and successfully run the program tests. An additional 10 points will be based on the style and formatting of your C++ code.

Style points

The 10 points for coding style will be based on the following guidelines:

• Comments at the start of your programming with a brief description of the purpose of the program.
• Comments throughout your program
• Proper formatting of your code (follow the guidelines in the Gaddis text book, or those used by your CS 1336 professor)
• If you have any variables they must have meaningful names.

Development in your IDE

For lab lesson 8 (both parts) you will be developing your solutions using an Integrated Development Environment (IDE) such as Visual Studio, Code::Blocks or Eclipse. You should use whatever IDE you are using for your CS 1336 class. Once you have created and tested your solutions you will be uploading the files to zyBooks/zyLabs. Your uploaded file must match the name specified in the directions for the lab lesson. You will be using an IDE and uploading the appropriate files for this and all future lab lessons.

For this and all future labs the name of the source files must be:

lessonXpartY.cpp

Where X is the lab lesson number (8 for lab lesson 8) and Y is the part number (1 for part 1, 2 for part 2).

You will need to develop and test the program in your IDE. Once you are satisfied that it is correct you will need to upload the source file to zyBooks/zyLabs, and submit it for the Submit mode tests. If your program does not pass all of the tests you need to go back to the IDE, and update your program to fix the problems you have with the tests. You must then upload the program from the IDE to zyBooks/zylabs again. You can then run the tests again in Submit mode.

When running your program in Submit mode it is very important that you look at the output from all of the tests. You should then try and fix all of the problems in your IDE and then upload the updated code to zyBooks/zyLabs.

C++ requirements

You are not allowed to use any global variables. Use of global variables will result in a grade of zero for part 1.

Your program must have function main, function presentValue, three read functions, and a display function. Including main this is six functions.

The presentValue function must have the following signature:

double presentValue(double futureValue, double interestRate, int numberYears)

The presentValue needs to calculate the present value and return that back to the calling function. The formula for this is above. Note that the annual interest would be .08 for 8%.

Failure to follow the C++ requirements could reduce the points received from passing the tests.

General overview

In part 2 you will be creating multiple functions to calculate the present value.

You may be asking what a “present value” is. Suppose you want to deposit a certain amount of money into a savings account and then leave it alone to draw interest for some amount of time, say 12 years. At the end of the 12 years you want to have $15,000 in the account. The present value is the amount of money you would have to deposit today to have $15,000 in 12 years.

The formula used needs the future value (F) and annual interest rate (r) and the number of years (n) the money will sit in the account, unchanged. You will be calculating the present value (P).

P = F / ( (1 + r) ^ n)

In the above expression the value (1 + r) needs to be raised to the nth power. Assume that ^ is the power function and x^2 is x to the 2nd power (x squared)

You are not allowed to use any global variables. Use of global variables will result in a grade of zero for part 2.

Three read functions

You must have functions to read in the future value, the annual interest rate, and the number of years. That would be three different functions. Give these functions meaningful names. Note that the order of the values will be future value, annual interest rate, and number of years.

In all cases you need to return any valid value back to the calling function.

For all three functions you will write out to cout as prompt for an input value. You will read in that value from cin. If the value is invalid (zero or negative) you need to display an error message and reread the value (with another prompt). You need to do this in a loop and continue looping until a valid value has been entered. Only the number of years can be an int value. The rest should be of type double.

Here are the prompts for the three values you need to read in:

Enter future value
Enter annual interest rate
Enter number of years

Note that the interest rate will be a number such as 10 or 12.5. These are to be read in as percentages (10% and 12.5%). You will need to divide these values by 100 to convert them into the values needed in the function (.1 and .125 for the above values). This conversion needs to be done before you call the presentValue function (see below). If you do the conversion in the presentValue function your program will fail the unit tests, so do the conversion before you call the calculate function.

Here are the error messages you need to display if the values are negative:

The future value must be greater than zero
The annual interest rate must be greater than zero
The number of years must be greater than zero

You will also need a function called presentValue with the following signature:

double presentValue(double futureValue, double interestRate, int numberYears)

The presentValue needs to calculate the present value and return that back to the calling function. The formula for this is above. Note that the annual interest would be .08 for 8%.

Note that the interest rate will be a number such as 10 or 12.5. These are to be read in as percentages (10% and 12.5%). You will need to divide these values by 100 to convert them into the values needed in the function (.1 and .125 for the above values). This conversion needs to be done before you call the presentValue function (see below). If you do the conversion in the presentValue function your program will fail the unit tests, so do the conversion before you call the calculate function.

The display function

You also need a function that displays the present value, future value, interest rate, and number of years. The function needs to display the interest rate as %, so .05 would display as 5.000%. Give your display function a meaningful name. You will be passing a number of values to this function.

Here is the sample output for a present value of $69,046.56, a future value of $100,000, an interest rate of 2.5% and a number of years of 15,

Present value: $69046.56
Future value: $100000.00
Annual interest rate: 2.500%
Years: 15

Note that the present value and future value have three digits of precision to the right of the decimal point but the interest rate only has one digit to the right of the decimal point.

The main function will be the driver for your program.

Your program will only be processing one set of valid values for future value, annual interest rate and number of years.

Get the values for these by calling the read functions you created above.

Once you have the values you need to call your presentValue. Using the result from the presentValue and the input values you read in with your read functions you need to call your display function (written above) to display the values.

The main function

The main function will be the driver for your program. All of the non-main functions are called from main.

For the following sample run assume the input is as follows:

1000000.0
5.0
25

Your program should output the following:

Enter future value
Enter annual interest rate
Enter number of years
Present value: $295302.77
Future value: $1000000.00
Annual interest rate: 5.000%
Years: 25

Here is an example with some invalid data

Input values:

-100
0
1000000.0
5.0
25

Output:

Enter future value
The future value must be greater than zero
Enter future value
The future value must be greater than zero
Enter future value
Enter annual interest rate
Enter number of years
Present value: $295302.77
Future value: $1000000.00
Annual interest rate: 5.000%
Years: 25

Failure to follow the requirements for lab lessons can result in deductions to your points, even if you pass the validation tests. Logic errors, where you are not actually implementing the correct behavior, can result in reductions even if the test cases happen to return valid answers. This will be true for this and all future lab lessons.

Expected output

There are eight tests. The first test will run your program with input and check your output to make sure it matches what is expected. The next three tests are unit tests. The unit tests will directly call the presentValue function. The compilation of the unit test could fail if your presentValue function does not have the required signature. The final four tests will run your program with various input values and make sure you are calculating the correct answers.

You will get yellow highlighted text when you run the tests if your output is not what is expected. This can be because you are not getting the correct result. It could also be because your formatting does not match what is required. The checking that zyBooks does is very exacting and you must match it exactly. More information about what the yellow highlighting means can be found in course “How to use zyBooks” – especially section “1.4 zyLab basics”.

Finally, do not include a system("pause"); statement in your program. This will cause your verification steps to fail.

Note: that the system("pause"); command runs the pause command on the computer where the program is running. The pause command is a Windows command. Your program will be run on a server in the cloud. The cloud server may be running a different operating system (such as Linux).

Error message “Could not find main function”

Now that we are using functions some of the tests are unit tests. In the unit tests the zyBooks environment will call one or more of your functions directly.

To do this it has to find your main function.

Right now zyBooks has a problem with this when your int main() statement has a comment on it.

For example:

If your main looks as follows:

int main() // main function

You will get an error message:

Could not find main function

You need to change your code to:

// main function
int main()

If you do not make this change you will continue to fail the unit tests.

It is important to understand the different types of attacks that can occur depending on both the operating system and underlying hardware in order to properly provide effective local-oriented cybersecurity defensive strategies.

Create a 10- to 15-slide or a 6- to 8-minute narrated presentation that outlines the vulnerabilities of embedded operating systems, such as, but not limited to, IoT devices, programmable logic devices, and vehicle control systems. This presentation can be created using your choice of presentation application as long as it is downloadable to the learning management system and/or instructor approved. Address the following within the presentation:

1. Discuss the tools used by hackers to penetrate these devices and the effects of each penetration type.
2. Provide insight as to how embedded operating system vendors provide defenses against hacking attempts
3. Describe, in steps, at least one strategy used to attack embedded operating systems.
4. Describe, in steps, at least one strategy used to defend against the chosen attack.
5. Explain ways in which you feel the programmers of embedded operating systems can improve on their existing attempts to secure the devices which host their programs.

This assignment uses a rubric (attached). Please review the rubric prior to beginning the assignment to become familiar with the expectations for successful completion.