Modify an existing Java Web application that violates several Payment Card Industry guidelines and recommendations. Your task is to locate the issues, identify what is wrong and then fix the code. You will discuss each issue in terms of why the issue may cause a security vulnerability, and how you specifically fixed the issue.

The current code, uses Java JSP and Servlets to allow a user to login to their account and view credit card data stored in the database. The functionality is relatively simple but several PCI compliance rules have been violated that will prevent the application from being approved by a PCI software auditor.

You should first load up the application, populate the database and make sure the application is working in your environment as expected. The application uses the Java Derby relational database. The script used to populate the application is attached as well as the Java web project itself. You should be able to open the existing project using NetBeans. However; you may need to load the Derby drivers to the libraries for the project.

Once you have the database loaded, you can try the application. (This assumes you have properly installed the Java EE when you installed NetBeans).

Email:john.doe@test.edu Password: mypassword

Review the code and perform analysis as needed. You should experiment with  application as well as reviewing the code to identify possible areas of security concerns. You don’t have to be an expert in JSP/Servlets, html or css to be able to find some of the issues that you have read about in the PCI documentation. However; it is recommended you experiment with the code so you have a baseline familiarity with the model and know how the JSP and servlets communicate with each other.

Focus on the PCI compliance issues found in sections 6 through 9 (see attached jpg file) as you look for issues. There are multiple issues and you should work to fix and document as many as possible.

Submission:

Provide all of your modified Java code, your modified database script and a word document describing how you addressed each issue. You should clearly describe the code and what PCI compliance issue were violated and how you fixed it. You should provide screen captures as needed to support your findings and improvements.

 Your organization moved forward with the implementation of a custom-developed enterprise resources planning solution. After several issues, extensive time spent troubleshooting, and failed user adoption, the implementation was deemed unsuccessful and management decided to continue with the old legacy system.

Management is concerned about future implementations, as the failed one cost considerable financial and personnel resources. Management wants to understand the issues so the failure is not repeated in the future. They have asked you to explain the types of things that can cause a seemingly well-planned implementation to fail. Provide an explanation and at least one example of an implementation that failed in the real world, including lessons learned from that failure.

// hw3_set.h // //CSc 212: Data Structures (Summer 2013) // set class for homework 3 // –> implemented using B-Trees // –> adapted from code written during lectures (7/1/03 – 7/3/03) namespace HW3 { class set { public: typedef int T; set() {entry_count=0; child_count=0;} bool insert(const T&); bool search(const T&); bool remove(const T&); void print(); private: static const int MIN = 3; static const int MAX = 2*MIN; T data[MAX+1]; int entry_count; set* subset[MAX+2]; int child_count; bool is_leaf() {return (child_count == 0);} bool loose_insert(const T&); void fix_excess(int); bool loose_erase(const T&); void remove_biggest(T&); void fix_shortage(int); }; } // end namespace HW3

For this project, you are going to write a program to find the anagrams in a given dictionary for a given word. If two words have the same letters but in different order, they are called anagrams. For example, “listen” and “silent” are a pair of anagrams.

**JAVA**

First let’s focus on “LetterInventory.java”.

Its purpose is to compute the canonical “sorted letter form” for a given word.

1. Implement the constructor, which takes the String input word. You can assume that the input word contains only valid letters (e.g. no punctuation or blanks), but it may contain letters in different cases.

2. Implement the method: public String getCanonical() It should return the canonical “sorted letter form” for the input word (given in the constructor). It should use only lower cases. For example, if the given word is “AliBaba”, then this method should return “aaabbil”.

****I have already completed all of the above tasks I am struggling with the next part****

**below is the code I have for LetterInventory.java**

import java.util.*;

public class LetterInventory {

   private String input;
 

    //stores the original word.
 

    public LetterInventory(String input) {
        this.input = input;
    }
    //uses an array of chars to hold word and sorts it into alphabetical order.
    //displays it in lower case.
    public String getCanonical() {
        input = input.toLowerCase(); // converting input to lower case
        char [] word = input.toCharArray();
        Arrays.sort(word);
        String sorted = new String (word);
        return sorted;
 

    }
}

*** this is where i am stuck ***

Once “LetterInventory.java” is working as expected, we can now focus on “AnagramFinder.java”. It will read an input “dictionary” file, which contains quite many words, to build a map. The “key” for the map is a word’s canonical form, the “value” for the map will be all the words in the given dictionary that share the same canonical form. For example, if both “listen” and “silent” are in the dictionary, one entry in the map would have key as “eilnst” and value as an ArrayList of words “listen” and “silent”.

Implement the constructor, which takes in the input dictionary file and build the map. You can assume the words in the dictionary contain only valid letters. You should take advantage of “LetterInventory”.

3. Now implement the method: public void printAnagrams(String word) It should try to search the anagrams for the given word in the map. Again, you can assume the input word contains only valid letters, and you should take advantage of “LetterInventory”.

Print out any anagrams found. For now, don’t worry about the case where the input word is the same as the word inside the dictionary, just print them out.

Here is some sample print out:

Your input is: silent. Found anagrams: listen, silent, tinsel.

Your input is: AliBaba. Sorry, didn’t find any anagrams.

A sample main method is already written for you to test various functionalities with some sample input words.

*** Below is the shell for the main method ***

import java.io.*;
import java.util.*;

public class AnagramFinder {
    public static void main(String[] args) throws FileNotFoundException {
        String[] originals = new String[] {
            “realfun”,
            “mias”,
            “EVIL”,
            “unable”,
            “Silent”,
            “AliBaba”
        };

       for(String original: originals) {
            LetterInventory inv = new LetterInventory(original);
            System.out.println(“Original: ” + original + “, Canonical: ” + inv.getCanonical());
        }

       System.out.println(“n”);

       File f = new File(“HW_sample_dict.txt”);
 

        AnagramFinder finder = new AnagramFinder(f);

       for(String original: originals) {
            finder.printAnagrams(original);
        }
    }

   public AnagramFinder(File f) throws FileNotFoundException {
       //TODO implement  
    }

   public void printAnagrams(String word) {
        //TODO implement
    }

   public void printAnagrams2(String word) {
        // Extra Credit: optional to implement
    }
}
 

** can leave out extra credit part i just need help with the first 2 methods in the main file **

** the dict.txt is 400 pages long so I did not include it (the file just contains thousands of words) **