Beispiel #1
0
func TestConfig(t *testing.T) {
	var tests = []struct {
		filename, protocol, host, port, path string
	}{
		{utils.GetUserHome() + "/.mdfs/stnode/.stnode_conf.json", "tcp", "localhost", "8081", utils.GetUserHome() + "/.mdfs/stnode/"},
		{utils.GetUserHome() + "/.mdfs/mdservice/.mdservice_conf.json", "tcp", "localhost", "1994", utils.GetUserHome() + "/.mdfs/mdservice/"},
	}
	for _, c := range tests {
		got := config.ParseConfiguration(c.filename)
		if got.Path != c.path || got.Host != c.host || got.Port != c.port || got.Protocol != c.protocol {
			t.Error("Configuration variables does not contain expected values\n")
			fmt.Printf("%s,%s,%s,%s,%s,%s,%s,%s\n", got.Path, c.path, got.Host, c.host, got.Port, c.port, got.Protocol, c.protocol)
		}
	}
}
Beispiel #2
0
func TestHash(t *testing.T) {
	var tests = []struct {
		path, filename string
		want           bool
	}{
		{utils.GetUserHome() + "/.testing_files/", "test.txt", true},
		{utils.GetUserHome() + "/.testing_files/", "test.jpg", true},
		{utils.GetUserHome() + "/.testing_files/", "testing", false},
	}
	for _, c := range tests {
		got := utils.CheckForHash(c.path, c.filename)
		if got != c.want {
			t.Errorf("CheckForHash(%q, %q) == %t, want %t", c.path, c.filename, got, c.want)
		}
	}
}
Beispiel #3
0
func (st *StorageNode) setUnid(unid string) (err error) {

	st.conf.Unid = unid
	err = config.SetConfiguration(st.conf, utils.GetUserHome()+"/.mdfs/stnode/.stnode_conf.json")
	if err != nil {
		return err
	}
	return err
}
Beispiel #4
0
func main() {

	err := os.MkdirAll(utils.GetUserHome()+"/.testing_files/", 0777)
	if err != nil {
		panic(err)
	}

	fo, err := os.Create(utils.GetUserHome() + "/.testing_files/test.txt")
	if err != nil {
		panic(err)
	}

	fi, err := os.Open("./testing_files/test.txt")
	if err != nil {
		panic(err)
	}

	_, err = io.Copy(fo, fi)
	if err != nil {
		panic(err)
	}

	fi.Close()
	fo.Close()

	fo, err = os.Create(utils.GetUserHome() + "/.testing_files/test.jpg")
	if err != nil {
		panic(err)
	}

	fi, err = os.Open("./testing_files/test.jpg")
	if err != nil {
		panic(err)
	}

	_, err = io.Copy(fo, fi)
	if err != nil {
		panic(err)
	}

	fi.Close()
	fo.Close()

}
Beispiel #5
0
// for testing setup
func main() {

	err := os.MkdirAll(utils.GetUserHome()+"/.mdfs/mdservice", 0700)
	if err != nil {
		panic(err)
	}
	err = os.MkdirAll(utils.GetUserHome()+"/.mdfs/mdservice/files/", 0700)
	if err != nil {
		panic(err)
	}

	conf := config.ParseConfiguration("./mdservice/config/mdservice_conf.json")
	conf.Path = utils.GetUserHome() + "/.mdfs/mdservice/"

	// save the new configuration to file
	err = config.SetConfiguration(conf, conf.Path+"/.mdservice_conf.json")
	if err != nil {
		panic(err)
	}
}
Beispiel #6
0
func request(r *bufio.Reader, w *bufio.Writer, currentDir string, args []string, thisUser *utils.User) (err error) {

	// should have args format:
	// request [remote filename] [local filename]
	// currently:
	// request [remote filename]
	// Local filename can be a relative or absolute path

	if len(args) < 2 {
		return err
	}

	// START SENDCODE BLOCK
	err = w.WriteByte(5)
	w.Flush()
	if err != nil {
		panic(err)
	}
	// END SENDCODE BLOCK

	// Send current dir
	w.WriteString(currentDir + "\n")
	w.Flush()

	// Format the file to send
	w.WriteString(args[1] + "\n")
	w.Flush()

	fmt.Println("Requesting: " + path.Join(currentDir, args[1]))

	success, _ := r.ReadByte()
	if success == 3 {

		fmt.Println("You do not have permission to request this file")
		return nil

	} else if success != 4 {

		fmt.Println("Invalid file request")
		return nil
	}

	protected := false
	enc, _ := r.ReadByte()
	if enc == 1 {
		protected = true
	}

	success, _ = r.ReadByte()
	if success != 2 {

		fmt.Println("No stnodes for your file")
		return nil
	}

	hash, _ := r.ReadString('\n')
	protocol, _ := r.ReadString('\n')
	nAddress, _ := r.ReadString('\n')

	hash = strings.TrimSpace(hash)
	protocol = strings.TrimSpace(protocol)
	nAddress = strings.TrimSpace(nAddress)

	conn, err := net.Dial(protocol, nAddress)
	if err != nil {
		fmt.Println("Error connecting to stnode")
	}

	ws := bufio.NewWriter(conn)
	rs := bufio.NewReader(conn)

	ws.WriteByte(1)

	bytehash, err := hex.DecodeString(hash)
	if err != nil {
		return err
	}

	err = utils.WriteHash(ws, bytehash)
	if err != nil {
		return err
	}

	success, _ = rs.ReadByte()
	if success != 3 {

		fmt.Println("File cannot be found on stnode")
		return err
	}

	output := utils.GetUserHome() + "/.mdfs/client/" + thisUser.Uname + "/files/" + path.Base(args[1])

	if protected {

		encrypFile := os.TempDir() + "/" + path.Base(args[1])
		utils.ReceiveFile(conn, rs, encrypFile)

		err = utils.DecryptFile(encrypFile, output, *thisUser)
		if err != nil {

			fmt.Println("Your key does not match the lock for this file")
			return nil
		}
		fmt.Println("Protected file successfully unlocked")

	} else {

		utils.ReceiveFile(conn, rs, output)

	}

	fmt.Println("Successfully received file")
	fmt.Println("File stored at: " + output)

	return
}
Beispiel #7
0
func setup(r *bufio.Reader, w *bufio.Writer, thisUser *utils.User) (err error) {

	fmt.Println("Please enter your username:\n")
	fmt.Print("Username: "******"/.mdfs/client/" + uname + "/.user_data")
	if exists != nil { // not exist

		// Make sure the local user dir exists
		err := os.MkdirAll(utils.GetUserHome()+"/.mdfs/client/"+uname+"/files", 0777)
		if err != nil {
			return err
		}

		// notify mdservice that this is a new user (SENDCODE 10)
		err = w.WriteByte(10) //
		if err != nil {
			return err
		}
		w.Flush()

		// local user setup
		utils.GenUserKeys(utils.GetUserHome() + "/.mdfs/client/" + uname + "/.private_key")

		err = utils.FileToStruct(utils.GetUserHome()+"/.mdfs/client/"+uname+"/.private_key", &thisUser.Privkey)
		if err != nil {
			return err
		}
		thisUser.Pubkey = &thisUser.Privkey.PublicKey

		// send username and keys
		w.WriteString(uname + "\n")
		w.Write([]byte(thisUser.Pubkey.N.String() + "\n"))
		w.Write([]byte(strconv.Itoa(thisUser.Pubkey.E) + "\n"))
		w.Flush()

		uuid, _ := r.ReadString('\n')
		thisUser.Uuid, err = strconv.ParseUint(strings.TrimSpace(uuid), 10, 64)
		if err != nil {
			return err
		}

		err = utils.StructToFile(*thisUser, utils.GetUserHome()+"/.mdfs/client/"+uname+"/.user_data")
		if err != nil {
			return err
		}

		//NOTE: NOT COMPLETE

	} else {

		err = utils.FileToStruct(utils.GetUserHome()+"/.mdfs/client/"+uname+"/.user_data", &thisUser)
		w.WriteByte(9)
		w.Flush()

	}

	return err

	// if none exist, will send a code to mdserv to notify as new user,
	// and get a uuid, create userkeys, send pubkey to mdserv

}
Beispiel #8
0
func main() {

	fmt.Println("This is the installation program for the MDFS")
	fmt.Println("----------------------------------------------------------")
	fmt.Println("Please select which software you would like to install")
	fmt.Println("1) Storage node software")
	fmt.Println("2) Metadata service")

	// get user selection
	reader := bufio.NewReader(os.Stdin)
	fmt.Print("\nEnter selection: ")
	selection, _ := reader.ReadString('\n')
	fmt.Println("----------------------------------------------------------")

	selection = strings.TrimSpace(selection)
	home := utils.GetUserHome()

	switch selection {
	case "1": // configure storage node
		path := home + "/.mdfs/stnode/"
		port := getPort(reader)
		host := getHost(reader)

		mdhost := getMdHost(reader)
		mdport := getMdPort(reader)

		err := setup(path, port, host, mdport, mdhost, "./storagenode/config/", "stnode_conf.json")
		if err != nil {
			panic(err)
		}

		// create a subdirectory called files
		err = os.MkdirAll(path+"./files", 0700)
		if err != nil {
			panic(err)
		}

		fmt.Println("Storage node has been initialised.")
		fmt.Printf("The configuration file can be found at %s.stnode_conf.json.\n", path)

	case "2": // configure metadata service
		path := home + "/.mdfs/mdservice/"
		port := getPort(reader)
		host := getHost(reader)

		err := setup(path, port, host, "", "", "./mdservice/config/", "mdservice_conf.json")
		if err != nil {
			panic(err)
		}

		// create a subdirectory called files
		err = os.MkdirAll(path+"./files", 0700)
		if err != nil {
			panic(err)
		}

		fmt.Println("Metadata service has been initialised.")
		fmt.Printf("The configuration file can be found at %s/.mdservice_conf.json.\n", path)

	default:
		fmt.Println("Invalid Selection.")
	}
}
Beispiel #9
0
func CheckCrypto() (success bool, err error) {

	usrHome := utils.GetUserHome()

	path := "/.testing_files/"

	keys := usrHome + path + ".private_key_mdfs"
	source1 := usrHome + path + "test.txt"
	encryp1 := usrHome + path + "test.enc"
	result1 := usrHome + path + "result.txt"

	source2 := usrHome + path + "test.jpg"
	encryp2 := usrHome + path + "test.jpg.enc"
	result2 := usrHome + path + "result.jpg"

	utils.GenUserKeys(keys)

	var prk *rsa.PrivateKey
	var puk *rsa.PublicKey

	err = utils.FileToStruct(keys, &prk)
	if err != nil {
		return false, err
	}
	puk = &prk.PublicKey

	user1 := utils.User{Uuid: 1, Pubkey: puk, Privkey: prk}
	user2 := utils.User{Uuid: 2, Pubkey: puk, Privkey: prk}

	//test two files for encryption and then decryption

	// Test 1st file
	users := []utils.User{user1, user2}

	err = utils.EncryptFile(source1, encryp1, users...)
	if err != nil {
		return false, err
	}
	err = utils.DecryptFile(encryp1, result1, user1)
	if err != nil {
		return false, err
	}
	err = utils.DecryptFile(encryp1, result1, user2)
	if err != nil {
		return false, err
	}

	test1 := compareFiles(source1, result1)

	// Test 2nd file
	err = utils.EncryptFile(source2, encryp2, user1)
	if err != nil {
		return false, err
	}
	err = utils.DecryptFile(encryp2, result2, user1)
	if err != nil {
		return false, err
	}

	test2 := compareFiles(source2, result2)

	return test1 && test2, err
}
Beispiel #10
0
// StorageNode methods
func (st *StorageNode) parseConfig() {
	st.conf = config.ParseConfiguration(utils.GetUserHome() + "/.mdfs/stnode/.stnode_conf.json")
}
Beispiel #11
0
// MDService methods
// initialise its memeber variable with values from config file
func (md *MDService) parseConfig() {
	md.conf = config.ParseConfiguration(utils.GetUserHome() + "/.mdfs/mdservice/.mdservice_conf.json")
}