Lab46 Wiki

User Tools

Site Tools

You are here: start » blog » fall2015 » dshadeck » journal
blog:fall2015:dshadeck:journal

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
blog:fall2015:dshadeck:journal [2015/09/29 13:39] – [September 21, 2015] dshadeckblog:fall2015:dshadeck:journal [2015/10/05 16:53] (current) – [September 28, 2015] dshadeck
Line 1: Line 1:
-=====HPC0=====+=====HPC 1=====
  
 ====August 31, 2015==== ====August 31, 2015====
Line 21: Line 21:
  
 Currently i have been thinking of projects that i can combine with my other existing courses to help save time and effort. The main class i have in mind is datacomm. Matt's guidelines were that the project had to have some sort of inspection and processing of data from a source. My first idea was to use wireshark & snort to filter local area network traffic and identify a specific pattern of packets in conjunction with a specific attack type. I am currently thinking of using ARP spoofing as the pattern i want to detect. This is for two reasons. first and foremost ARP spoofing is an extremely simple yet effective attack that works on a LAN level only. Being able to avoid this easy attack on your local area network can save many headaches. Secondly ARP packets are extremely unique in comparison to others. This would allow for very easy filtering and capture of these packets only.  Currently i have been thinking of projects that i can combine with my other existing courses to help save time and effort. The main class i have in mind is datacomm. Matt's guidelines were that the project had to have some sort of inspection and processing of data from a source. My first idea was to use wireshark & snort to filter local area network traffic and identify a specific pattern of packets in conjunction with a specific attack type. I am currently thinking of using ARP spoofing as the pattern i want to detect. This is for two reasons. first and foremost ARP spoofing is an extremely simple yet effective attack that works on a LAN level only. Being able to avoid this easy attack on your local area network can save many headaches. Secondly ARP packets are extremely unique in comparison to others. This would allow for very easy filtering and capture of these packets only. 
 +
 +====October 5, 2015====
 +
 +My arp spoofing project is under way! Currently I have two Windows 10 virtual machines set up and running cain and able. This is the program I will be using to do the ARP spoofing attacks. I have been looking into Linux options for ARP spoofing as well as creating my own programs to do this. For now this is the quickest option. The next step will be to set up a service that is vulnerable to ARP spoofing to demonstrate its uses. For this i have been considering an apache web server using http instead of https. This would allow me to see if the spoofing actually worked to capture the unencrypted traffic sent between the web server and the spoofed host. to capture this traffic i will use wireshark. This will give me a pcap format file to sift through and find arp packets. From there i will creat a script that can take in a MAC address and search for arp packets that match the address. As i write this i am thinking of issues with this and maybe i need to do some more brainstorming and testing. BLAGHHH.
 =====Data Structures===== =====Data Structures=====
  
Line 421: Line 425:
 </code> </code>
  
 +====October 5, 2015====
 +#include "list.h"
 +<code c>
 +//////////////////////////////////////////////////////////////////////
 +//
 +//   insert() - add a new node to the given list before the node
 +//              at the indicated place. insert() needs to manage
 +//              the necessary connections pointers) to maintain list
 +//              integrity, along with ensuring the start and end
 +//              indicators of the list remain relevant and up-to-date.
 +//
 +//    behavior: on a NULL list- allocate a list and proceed
 +//              on a NULL newNode- return list as is
 +//
 +//        note: you are expected to make use of the getpos() and
 +//              setpos() functions to aid you in accomplishing this
 +//              task. Don't needlessly reinvent the wheel.
 +//
 +//              as with the other functions, you may use no more
 +//              than one return() statement per function.
 +//
 +List *insert(List *myList, Node *place, Node *newNode)
 +{
 +        if(myList == NULL) { //check if list is NULL
 +                myList = mklist(); //make new list
 +        }
 +        if(newNode != NULL) { //checks if newNode is not NULL
 +                if(myList -> first == NULL || myList -> last == NULL) { //checks beginning and end
 +                        myList -> first = newNode;
 +                        myList -> last = newNode;
 +                } else {
 +                        int pos = getpos(myList, place);
 +                        if(pos == 0) {
 +                                myList -> first = newNode;
 +                        } else {
 +                                Node *before = setpos(myList, pos - 1); //set pos
 +                                before -> after = newNode;
 +                        }
 +                        newNode -> after = place;
 +                }
 +        }
 +        //returns
 +        return(myList);
 +}
 +
 +// Author: Dan Shadeck
 +// 09/29/2015
 +// Data Structures
 +</code>
 +
 +<code c>
 +#include <stdio.h>
 +#include "list.h"
 +
 +//////////////////////////////////////////////////////////////////////
 +//
 +// displayf() - display the list in a specified orientation, also
 +//              with or without positional values (as indicated
 +//              by the mode parameter).
 +//
 +//       modes: 0 display the list forward, no positional values
 +//              1 display the list forward, with positional values
 +//     
 +//        note: positional values are indexed starting from 0
 +//     
 +//    behavior: on a NULL list, output "NULL"
 +//              on an EMPTY list, output "-> NULL"
 +//              on error (invalid mode): MOD by 2 and do the result
 +//                 (or the logical equivalent)
 +//
 +//      format: output is to be on a single line, with node values
 +//              space-padded. and separated by "->" sequences, flush
 +//              against the left margin, of the forms:
 +//
 +// for forward:   val0 -> val1 -> val2 -> ... -> valN-1 -> valN -> NULL
 +//
 +//              or, if being displayed with node positions:
 +//
 +// for forward: [0] val0 -> [1] val1 -> ... -> [N-1] valN-1 -> [N] valN -> NULL
 +//
 +//        note: ALL output ends with a newline character
 +//
 +void displayf(List *myList, int mode)
 +{
 +        if(myList == NULL) {
 +                printf("NULL\n");
 +        } else if (mode==0){
 +                Node *tmp = myList -> first;
 +                char ran = 'f';
 +                while (tmp != NULL){
 +                        ran = 't';
 +                        printf ("%hhd -> ", tmp -> info);
 +                        tmp = tmp -> after; // getting the next value
 +                }
 +                if(ran == 't') {
 +                        printf("NULL\n");
 +                } else {
 +                        printf("-> NULL\n");
 +                }
 +        } else if (mode==1){
 +                Node *tmp = myList -> first;
 +                int count = 0;
 +                char ran = 'f';
 +                while (tmp != NULL){
 +                        ran = 't';
 +                        printf ("[%d] %hhd -> ", count, tmp -> info);
 +                        tmp = tmp -> after; //getting the next value
 +                        count++;        //incr count to give us node position 
 +                }
 +                if(ran == 't') {
 +                        printf("NULL\n");
 +                } else {
 +                        printf("-> NULL\n");
 +                }
 +        }
 +}
 +
 +// this is displaying the list with or with out position values
 +
 +// Author: Dan Shadeck
 +// 09/29/2015
 +// Data Structures
 +
 +</code>
 +
 +<code c>
 +//////////////////////////////////////////////////////////////////////
 +//
 +// getpos() - a list library utility function to identify the actual
 +//            position of a given node in an indicated list.
 +//
 +//      note: Indexing of the list starts from 0
 +//
 +//  behavior: on error (NULL list or given node), return negative
 +//            value (-1), on out-of-bounds condition, return -2
 +//
 +//            you are to have only ONE return statement for this
 +//            entire function. Change the existing one as needed.
 +//
 +int getpos(List *myList, Node *given)
 +{
 +    int count = 0;
 +        char broke = 'f';
 +        if(myList == NULL || given == NULL) { //checks if both list and given are NULL
 +                count = -1;
 +        } else {
 +                Node *tmp = myList -> first;
 +        while (tmp != NULL){
 +                if (tmp == given){
 +                broke = 't';
 +                break;
 +                }
 +                tmp = tmp -> after; //getting the next value
 +                count++;    //incr count to give us node position 
 +        }
 +        }
 +    if(broke == 'f' && count != -1) {// checks if loop broke
 +                count = -2;
 +        }
 +        return(count);
 +}
 +
 +//////////////////////////////////////////////////////////////////////
 +//
 +// setpos() - a list library utility function to set a node pointer
 +//            to the node at the indicated position of a list.
 +//
 +//      note: Indexing of the list starts from 0
 +//
 +//  behavior: on error (NULL list or negative/out-of-bounds pos),
 +//            return NULL.
 +//
 +//            you are to have only ONE return statement for this
 +//            entire function. Change the existing one as needed.
 +//
 +Node *setpos(List *myList, int pos)
 +{
 +        //returning node variable
 +        Node *node = NULL;
 +        if(myList != NULL && pos >= 0) { //checking if list is null and pos index
 +                Node *tmp = myList -> first;
 +                int counter = 0;
 +                while(tmp != NULL) {//while loop; checks tmp not NULL
 +                        if(counter == pos) {
 +                                node = tmp;
 +                                break;
 +                        }
 +                        tmp = tmp -> after;
 +                        counter++;
 +                }
 +        }
 +        //returns
 +        return(node);
 +}
 +
 +// Author: Dan Shadeck
 +// 09/29/2015
 +// Data Structures
 +
 +</code>
 +
 +<code c>
 +#include "list.h"
 +
 +//////////////////////////////////////////////////////////////////////
 +//
 +// mklist() - a list library function to allocate and initialize a 
 +//            new list.
 +//
 +//  behavior: on error, return NULL.
 +//
 +//      note: you are to have only ONE return statement for this
 +//            entire function. Change the existing one as needed.
 +//
 +List *mklist(void)
 +{
 +        List *newlist = (List *) malloc(sizeof(List)); //allocating mem 
 +
 +        return(newlist);  
 +
 +}
 +
 +// extra comment just to be clear that this is a list library function to allocate and initialize a new list
 +
 +// Author: Daniel Shadeck
 +// 9/29/2015
 +// Data Structures
 +
 +</code>
 =====Data Communications===== =====Data Communications=====
  
Line 995: Line 1228:
  
 </code> </code>
 +
 +====October 5, 2015====
 +
 +Lets hope that today we have a break through on the chart.
blog/fall2015/dshadeck/journal.1443533999.txt.gz · Last modified: 2015/09/29 13:39 by dshadeck

Page Tools

Except where otherwise noted, content on this wiki is licensed under the following license: CC Attribution-Share Alike 4.0 International
CC Attribution-Share Alike 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki