private static string GetAuthRequestURI (RequestObject request) {
// We need to build the relative URI
StringBuilder relativeURI = new StringBuilder();
relativeURI.Append (@"golang/get/auth/");
relativeURI.Append (request.Fields["application"]);
return relativeURI.ToString ();
}
public async Task<ResponseObject> SendDatabaseRequest (RequestObject request) {
var returnObj = new ResponseObject();
using (var client = new HttpClient ()) {
client.BaseAddress = new Uri(this.url);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(@"application/json"));
string relativePath;
switch (request.RequestType) {
case RequestType.GetAuthenticationRequest:
{
relativePath = GetAuthRequestURI (request);
break;
}
case RequestType.GetAuthenticationUsernameRequest:
{
relativePath = GetAuthUserURI (request);
break;
}
case RequestType.GetFieldRequest:
{
relativePath = GetFieldRequestURI (request);
break;
}
case RequestType.PostFieldRequest:
{
relativePath = PostFieldRequestURI (request);
break;
}
case RequestType.PostCreateUser:
{
relativePath = PostCreatePrintURI (request);
break;
}
case RequestType.DeleteFieldRequest:
{
relativePath = DeleteFieldURI (request);
break;
}
default:
{
throw new NotImplementedException ();
}
}
StringContent requestContent = new StringContent(JsonConvert.SerializeObject(request));
using (var response = await client.PostAsync (relativePath, requestContent)) {
if (response.IsSuccessStatusCode) {
// We've received a successful response. Sweet :)
var body = await response.Content.ReadAsStringAsync ();
returnObj = JsonConvert.DeserializeObject<ResponseObject> (body);
} else {
// We've encountered an error.
Console.WriteLine ("Error Parsing JSON");
}
}
}
return returnObj;
}
public static async void TempAction (Object obj) {
string url = "https://www.peterglotfelty.com:8000/";
while (true) {
Console.WriteLine ("What application are you running?");
string app = Console.ReadLine ();
Console.WriteLine ("Please enter your fingerprint :)");
string fingerprint = Console.ReadLine ();
Console.WriteLine ("Sending Request to url:");
var remote = new RemoteConnectionManager (url);
var req = new RequestObject (RequestType.GetAuthenticationRequest, app);
req.Fields.Add ("fingerprint", fingerprint);
req.Fields.Add ("application-password", "justice-league");
var res = await remote.SendDatabaseRequest (req);
Console.WriteLine ("Response received");
Console.WriteLine ("The session id is: {0}", res.SessionID);
Console.WriteLine ("What field would you like to retrieve?");
string field = Console.ReadLine ();
req = new RequestObject (RequestType.GetFieldRequest, app);
req.Fields.Add ("fieldname", field);
req.Fields.Add ("sessionID", res.SessionID);
Console.WriteLine ();
Console.WriteLine ("Sending request for field");
res = await remote.SendDatabaseRequest (req);
Console.WriteLine ("The response contains:");
foreach (var response in res.Responses) {
Console.WriteLine (response);
}
string cont = "y";
Console.WriteLine ();
Console.WriteLine ("Would you like to continue (y/n)?");
cont = Console.ReadLine ();
if (cont.ToLower () == "n") {
break;
}
}
((Semaphore)obj).Release ();
}
private static string GetAuthUserURI (RequestObject request) {
StringBuilder relativeURI = new StringBuilder();
relativeURI.Append (@"golang/get/auth_usr/");
relativeURI.Append (request.Fields["application"]);
return relativeURI.ToString ();
}
private static string PostCreatePrintURI (RequestObject request) {
StringBuilder relativeURI = new StringBuilder();
relativeURI.Append (@"golang/post/create_usr/");
relativeURI.Append (request.Fields["username"]);
return relativeURI.ToString ();
}
private static string DeleteFieldURI (RequestObject request) {
StringBuilder relativeURI = new StringBuilder();
relativeURI.Append (@"golang/delete/field/");
relativeURI.Append (request.Fields["fieldname"]);
return relativeURI.ToString ();
}
//Disable the "async" warning until we actually implement the async parts.
#pragma warning disable 1998
private static async void HandleRequest (IAsyncResult result)
{
// Note for all of this:
// We're good as long as async operators work fine across platforms.
// We will enter into callback hell if they don't.
HttpListener listener = (HttpListener)result.AsyncState;
HttpListenerContext context = listener.EndGetContext (result);
var httpRequest = context.Request;
RequestObject requestObject = new RequestObject ();
requestObject.RequestType = RequestType.InvalidRequest;
ResponseObject databaseResponse = new ResponseObject ();
try {
requestObject = ParseRequest (httpRequest);
if (requestObject.RequestType == RequestType.InvalidRequest) {
// Handle us receiving a malformed request.
throw new Exception("The request could not be properly parsed");
}
// Console.WriteLine (requestObject.RequestType);
// =================================================================
// Open a connection to the peripheral so that we can receive
// a finger print from the user.
// =================================================================
if (requestObject.RequestType == RequestType.GetAuthenticationRequest) {
// Console.WriteLine ("Please enter your fingerprint:");
// var user = Console.ReadLine ();
// var temp = new List<string>() {"Batman", "Superman", "Flash", "Wonderwoman", "Green Lantern", "Spiderman", "Green Arrow"};
// string user;
// lock (o) {
// user = temp [r.Next (temp.Count)];
// }
//
// // Randomly authenticate one of our users.
// requestObject.Fields.Add ("fingerprint", user);
PeripheralConnection peripheral = PeripheralConnection.Instance;
// This either opens a new connection or simply verifies the existing
// connection is good.
await m.WaitAsync();
await peripheral.TryOpenConnection ();
m.Release();
await peripheral.RequestTemplate(requestObject);
}
RemoteConnectionManager databaseManager = new RemoteConnectionManager (connectionString);
databaseResponse = await databaseManager.SendDatabaseRequest (requestObject);
}
catch (Exception ex) {
Console.WriteLine (ex.Message);
}
finally {
var responseText = GenerateResponse (requestObject, databaseResponse);
var responseBytes = System.Text.Encoding.UTF8.GetBytes (responseText);
// Pretty simple, get a handle to the response packet and the output stream.
var httpResponse = context.Response;
httpResponse.ContentLength64 = responseBytes.Length;
var outputStream = httpResponse.OutputStream;
// Write the response to the buffer and then close the connection. Note that
// These might take a while to do.
outputStream.Write (responseBytes, 0, responseBytes.Length);
outputStream.Close ();
}
}
private static string PostFieldRequestURI (RequestObject request) {
// We need to build the relative URI
StringBuilder relativeURI = new StringBuilder();
relativeURI.Append (@"golang/post/field/");
relativeURI.Append (request.Fields["fieldname"]);
return relativeURI.ToString ();
}
private static RequestObject ParseReqDeleteField (HttpListenerRequest request) {
var url = request.Url;
var returnObj = new RequestObject ();
returnObj.RequestType = RequestType.DeleteFieldRequest;
var fieldname = url.AbsolutePath.Split ('/').Last ();
returnObj.Fields.Add("fieldname", fieldname);
var query = ParseQueryString (url);
IEnumerable<string> sessionID;
StreamReader bodyReader = new StreamReader (request.InputStream);
List<string> values;
try {
values = Newtonsoft.Json.JsonConvert.DeserializeObject<List<string>>(bodyReader.ReadToEnd());
}
catch {
returnObj.RequestType = RequestType.InvalidRequest;
return returnObj;
}
if (query.TryGetValue("sessionID", out sessionID)) {
returnObj.Fields.Add("sessionID", sessionID.First ());
returnObj.Values.AddRange (values);
} else {
// Just reassign the request type and invalidate the whole thing.
returnObj.RequestType = RequestType.InvalidRequest;
}
return returnObj;
}
private static string GenerateResponse (RequestObject request, ResponseObject dbResponse) {
switch (request.RequestType) {
case RequestType.GetAuthenticationRequest:
{
List<string> output = new List<string> ();
output.Add (dbResponse.SessionID);
output.Add (dbResponse.ResponseCode.ToString ());
return JsonConvert.SerializeObject (output);
}
case RequestType.GetFieldRequest:
{
dbResponse.Responses.Add (dbResponse.ResponseCode.ToString ());
return JsonConvert.SerializeObject (dbResponse.Responses);
}
case RequestType.PostFieldRequest:
{
List<string> output = new List<string> ();
output.Add (dbResponse.ResponseCode.ToString ());
return JsonConvert.SerializeObject (output);
}
case RequestType.PostCreateUser:
{
break;
}
case RequestType.DeleteFieldRequest:
{
List<string> output = new List<string> ();
output.Add (dbResponse.ResponseCode.ToString ());
return JsonConvert.SerializeObject (output);
}
}
return String.Empty;
}
private static RequestObject ParseReqPostCreateUser (HttpListenerRequest request) {
var url = request.Url;
var returnObj = new RequestObject ();
returnObj.RequestType = RequestType.PostCreateUser;
var username = url.AbsolutePath.Split ('/').Last ();
returnObj.Fields.Add ("username", username);
var query = ParseQueryString (url);
IEnumerable<string> password;
if (query.TryGetValue ("password", out password)) {
returnObj.Fields.Add("password", password.First());
} else {
// Just reassign the request type and invalidate the whole thing.
returnObj.RequestType = RequestType.InvalidRequest;
}
return returnObj;
}
private static RequestObject ParseReqGetField (HttpListenerRequest request) {
var url = request.Url;
var returnObj = new RequestObject ();
returnObj.RequestType = RequestType.GetFieldRequest;
var fieldname = url.AbsolutePath.Split ('/').Last ();
returnObj.Fields.Add("fieldname", fieldname);
var query = ParseQueryString (url);
if (query.ContainsKey("sessionID")) {
returnObj.Fields.Add("sessionID",query["sessionID"].First());
} else {
// Just reassign the request type and invalidate the whole thing.
returnObj.RequestType = RequestType.InvalidRequest;
}
return returnObj;
}
private static RequestObject ParseReqAuthUsr (HttpListenerRequest request) {
var url = request.Url;
var returnObj = new RequestObject ();
returnObj.RequestType = RequestType.GetAuthenticationUsernameRequest;
var application = url.AbsolutePath.Split ('/').Last ();
returnObj.Fields.Add ("application", application);
var query = ParseQueryString (url);
IEnumerable<string> username;
IEnumerable<string> password;
IEnumerable<string> applicationPassword;
if (query.TryGetValue ("username", out username)
&& query.TryGetValue ("password", out password)
&& query.TryGetValue("application-password", out applicationPassword)) {
returnObj.Fields.Add ("username", username.First ());
returnObj.Fields.Add ("password", password.First ());
returnObj.Fields.Add ("application-password", applicationPassword.First());
} else {
// Just reassign the request type and invalidate the whole thing.
returnObj.RequestType = RequestType.InvalidRequest;
}
return returnObj;
}
private static RequestObject ParseReqAuth (HttpListenerRequest request) {
var url = request.Url;
var application = url.AbsolutePath.Split ('/').Last ();
var query = ParseQueryString (url);
var returnObj = new RequestObject(RequestType.GetAuthenticationRequest, application);
if (query.ContainsKey ("application-password")) {
returnObj.Fields.Add("application-password", query ["application-password"].First ());
} else {
returnObj.RequestType = RequestType.InvalidRequest;
}
return returnObj;
}
// We've set it up this way so that if another task has already requested
// verification then we can just wait for that one to finish
// instead of trying to start over.
public async Task RequestTemplate (RequestObject request) {
// if (!IsOpen) {
// request.Fields.Add ("fingerprint", "");
// return;
// }
lock (obj) {
if (!this.isCommunicatingWithTemplate) {
this.isCommunicatingWithTemplate = true;
ThreadPool.QueueUserWorkItem (InternalRequestTemplate);
}
}
string template = await templateCompletedTask.Task;
await templateBlockingTask.Task;
request.Fields.Add ("fingerprint", template);
}
