-
Notifications
You must be signed in to change notification settings - Fork 0
/
fifoclient.py
executable file
·146 lines (127 loc) · 5.11 KB
/
fifoclient.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#!/usr/bin/python
import sys
import os
import socket
import ssl
import json
import argparse
import base64
from classes import RendezVous, Exchange
from tcp_transfer import (
TCP_FERNET, TCP_ACBC, TCP_AGCM, TCP_UPnP
)
from config import *
class FifoClient(RendezVous):
def initialization(self, server_ip, server_port):
self._server_ip = server_ip
self._server_port = server_port
def register(self, host_ip, host_port, algo):
return self._send("post", self._token, host_ip, host_port, algo)
def retreive(self):
return self._send("get", self._token)
def _send(self, method, token, ip=None, port=None, algo=None):
msg = json.dumps({"method" : method,
"token": token,
"ip" : ip,
"port": port,
"algo" : algo
})
context = ssl.create_default_context()
context.check_hostname = False
context.load_verify_locations(CERT_FILE)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s = context.wrap_socket(s)
s.connect((self._server_ip, self._server_port))
while True:
s.sendall(msg.encode())
data = s.recv(MSG_SIZE)
if data:
return data
else:
break
s.close()
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("task", choices=["get", "send"],
help="Can be either 'send' or 'get'")
parser.add_argument("path", help="Path to write or read the file")
parser.add_argument("password", help="""Password used to retreive your peer,
you must give a string and a number of your choice, e.g: password,1337""")
parser.add_argument("-p", "--tcp-port", type=int, default=TCP_PORT,
help="Specify the port used for file transfer")
parser.add_argument("-s", "--server-host",
help="Specify the RendezVous server address to use, format: ip:[port]")
parser.add_argument("-u", "--use-upnp", action="store_true",
help="Use UPnP IGD to forward the tcp port to \
your machine, may not be allowed by all routers")
parser.add_argument("-g", "--use-aes-gcm", action="store_true",
help="""
Use AES GCM instead of Fernet for data encryption,
use this option when you have to transfer large files.
""")
parser.add_argument("-c", "--use-aes-cbc", action="store_true",
help="""
Use AES CBC instead of Fernet for data encryption,
can be used to transfer large files or for performance.
/!\ You will get no packet authentification, only
encryption /!\.
""")
args = parser.parse_args()
token = args.password
rdv = FifoClient(token)
if args.server_host:
host = args.server_host.split(":")
serv_ip = host[0]
if len(host) == 2:
serv_port = int(host[1])
else:
serv_port = SERVER_PORT
else:
serv_ip, serv_port = SERVER_IP, SERVER_PORT
rdv.initialization(server_ip=serv_ip, server_port=serv_port)
if args.task == "send":
if not os.access(args.path, os.R_OK):
print("File is not readable")
sys.exit(1)
bases = []
if args.use_upnp:
bases.append(TCP_UPnP)
if args.use_aes_gcm:
algo = "AES-GCM"
bases.append(TCP_AGCM)
elif args.use_aes_cbc:
algo = "AES-CBC"
bases.append(TCP_ACBC)
else:
algo = "FERNET"
bases.append(TCP_FERNET)
transfer = type("Transfer", tuple(bases), {})(port=args.tcp_port)
exch = Exchange(rdv, transfer)
res = exch.register(host_ip="", host_port=args.tcp_port, algo=algo)
res = json.loads(res)
try:
transfer.initialization(res["msg"])
except:
print("You must give a password in the format string,integer")
sys.exit(1)
print("Waiting for file to be pick up, encryption: "+algo)
exch.serve(args.path)
print("Transfer completed.")
elif args.task == "get":
if not os.access(os.path.split(args.path)[0], os.W_OK):
print("File is not writable")
sys.exit(1)
result = json.loads(rdv.retreive())
if not "msg" in result:
transfer = {
"AES-GCM" : TCP_AGCM, "AES-CBC" : TCP_ACBC,
"FERNET" : TCP_FERNET
}[result["algo"]]()
transfer.initialization(result["key"])
exch = Exchange(rdv, transfer)
print("""Starting TCP transfer with {} encryption algorithm
...""".format(result["algo"]))
exch.get((result["ip"], result["port"]), args.path)
print("Transfer completed.")
else:
print("Failed to get file: " + result["msg"])