public static void RegisterNewUser()
{
bool isUserCreated = false;
var api = new API();
do
{
Console.Clear();
Console.Write("Enter new user name: \n");
var userName = Console.ReadLine();
Console.Write("Enter new password: \n");
var password = Console.ReadLine();
Console.Write("Enter new password again: \n");
var passwordVerify = Console.ReadLine();
var result = api.Register(userName, password, passwordVerify);
if (result == false)
{
var input = RegisterMessage.Error();
if (input != "")
{
Console.Clear();
break;
}
}
else
{
RegisterMessage.Success(userName, password);
isUserCreated = true;
}
} while (isUserCreated == false);
}
public bool Register(RegisterMessage message)
{
bool retval = false;
if (string.IsNullOrEmpty(message.UserId) ||
string.IsNullOrEmpty(message.PublicKey))
{
return(false);
}
try
{
byte[] publicKeyBuffer = Convert.FromBase64String(message.PublicKey);
// Hash the public key.
SHA256 hashalg = SHA256.Create();
byte[] publicKeyHashBuffer = hashalg.ComputeHash(publicKeyBuffer);
string publicKeyHash = Convert.ToBase64String(publicKeyHashBuffer);
retval = DAL.Instance.RegisterUser(message.UserId, publicKeyBuffer, publicKeyHash, message.DeviceName);
}
catch (Exception)
{
}
return(retval);
}
public void RegisterMessageSerializationTest()
{
var problemList = new List <string>()
{
"DVRP"
};
var registerMessage = new RegisterMessage(EComponentType.TaskManager, 1, problemList);
var result = registerMessage.SerializeToXml();
Assert.IsNotNull(result);
Assert.AreNotEqual(0, result.Length);
var xmlValidator = new XmlValidator();
var xsdSchemaFile = "RegisterMessage.xsd";
var xsdSchemaPath = Path.Combine(_xsdSchemasPath, xsdSchemaFile);
var validationResult = xmlValidator.Validate(result, xsdSchemaPath, true);
var errorsCount = validationResult.Errors.Count + validationResult.Warnings.Count;
Assert.AreEqual(0, errorsCount);
#region ExampleResult
//<?xml version="1.0" encoding="utf-16"?>
//<Register xmlns="http://www.mini.pw.edu.pl/ucc/">
// <Type>TaskManager</Type>
// <SolvableProblems>
// <ProblemName>DVRP</ProblemName>
// </SolvableProblems>
// <ParallelThreads>1</ParallelThreads>
//</Register>
#endregion
}
public async Task <bool> CreateAdmin(RegisterMessage message)
{
var user = new User
{
Id = Guid.NewGuid().ToString(),
Email = message.Email,
Username = message.Username,
Nickname = message.Username,
Image = "default.png",
Location = "",
FollowersCount = 0,
FollowingCount = 0,
Verified = true
};
_userContext.Add(user);
_userContext.SaveChanges();
await _messagePublisher.PublishMessageAsync("NewAdminMessage", new { Id = user.Id, Email = user.Email, Username = user.Username, Password = message.Password });
await _messagePublisher.PublishMessageAsync("NewProfileMessage",
new { Id = user.Id, Username = user.Username, Nickname = user.Nickname, Image = user.Image });
return(true);
}
public RegisterReplyMessage addUser(RegisterMessage message, UserInfo user)
{
RegisterReplyMessage replyMessage = new RegisterReplyMessage(message);
if (manager.database.conn.KeyExists("usernames:" + user.username))
{
replyMessage.reply = RegisterReplyMessage.registerReply.USEREXISTS;
return(replyMessage);
}
string id = Guid.NewGuid().ToString();
HashEntry[] entries =
{
new HashEntry("id", id),
new HashEntry("username", user.username),
new HashEntry("password", user.password),
new HashEntry("permissions", (int)user.permissions)
};
manager.database.conn.HashSet("user:"******"username", user.username),
new HashEntry("id", id)
};
manager.database.conn.HashSet("usernames:" + user.username, entries2);
replyMessage.reply = RegisterReplyMessage.registerReply.SUCCESS;
replyMessage.user = user;
return(replyMessage);
}
/// <summary>
/// Sends a join request to RegistrarServer and returns the confirmation number. This method opens
/// a connection to the server sends a request message, receives a response message and closes the
/// connection to the server.
/// </summary>
/// <param name="groupIP">The group IP address to join</param>
/// <param name="groupPort">The group port number to join</param>
/// <returns>The RTP unicast port</returns>
public int join(IPAddress groupIP, int groupPort)
{
try
{
// Creating and initializing the network related objects.
TcpClient tcpC = new TcpClient(regSrvIP.AddressFamily);
tcpC.Connect(regSrvIP, regSrvPort);
NetworkStream netStream = tcpC.GetStream();
BinaryFormatter bf = new BinaryFormatter();
joiningMulticastEP = new IPEndPoint(groupIP, groupPort);
// Building the message to be sent to RegistrarServer (MessageType: Join)
RegisterMessage regMsg = new RegisterMessage(MessageType.Join, groupIP, groupPort);
// Sending the message request object to the RegistrarSErver
bf.Serialize(netStream, regMsg);
// Receiving the message response object from the RegistrarServer
Object obj = bf.Deserialize(netStream);
regMsg = (RegisterMessage)obj;
// Closing the server connection.
tcpC.Close();
// Saving the confirmation number and RTP unicast port
refSrvCookie = regMsg.confirmNumber;
return(regMsg.unicastPort);
}
catch (Exception e)
{
eventLog.WriteEntry("Join request to server " + regSrvIP + ":" + regSrvPort +
"for " + joiningMulticastEP + " failed. \n" + e.ToString(), System.Diagnostics.EventLogEntryType.Error, (int)RtpEL.ID.ReflectorJoinFailed);
throw;
}
}
/// <summary>
/// Initialize ChromaSDK and get SessionId.
/// </summary>
/// <param name="jsonMessage">Application information as JSON string</param>
/// <returns>SessionId as string</returns>
public async Task <string> Register(string jsonMessage)
{
var registerMessage = new RegisterMessage(jsonMessage);
var response = await Request(registerMessage).ConfigureAwait(false);;
var result = JsonConvert.DeserializeObject <Dictionary <string, string> >(response, new JsonSerializerSettings());
if (!result.ContainsKey("sessionid"))
{
throw new ChromaNetCoreApiException($"Error when register API client: {response}");
}
sessionId = result["sessionid"];
var newExposedBaseAddress = new Uri(result["uri"]);
#if DEBUG
if (Bootstrapper.DebugMode)
{
newExposedBaseAddress = new Uri(result["uri"].Replace("localhost", "localhost.fiddler"));
}
#endif
ClientConfiguration.ExposedBaseAddress = newExposedBaseAddress;
return(sessionId);
}
public void RegisterAtServer()
{
var registerMessage = new RegisterMessage()
{
ParallelThreads = 1,//???
SolvableProblems = new string[] { "DVRP" },
Type = RegisterType.TaskManager
};
var messageString = SerializeMessage(registerMessage);
var socket = communicationModule.SetupClient();
communicationModule.Connect(socket);
communicationModule.SendData(messageString, socket);
var response = communicationModule.ReceiveData(socket);
var deserializedResponse = DeserializeMessage <RegisterResponseMessage>(response);
this.NodeId = deserializedResponse.Id;
this.Timeout = deserializedResponse.TimeoutTimeSpan;
communicationModule.CloseSocket(socket);
_logger.Info("Succesfully registered at server. Assigned id: " + this.NodeId + " received timeout: " +
deserializedResponse.Timeout);
}
/// <summary>
/// Sends a leave request to RegistrarServer for groupIP and groupPort. This method opens
/// a connection to the server sends a request message, receives a response message and closes the
/// connection to the server.
/// </summary>
/// <param name="groupIP">The group IP address to leave</param>
/// <param name="groupPort">The group Port number to leave</param>
/// <param name="confirmNumber">The confirmation number received from the RegistrarServer at the join time</param>
public void leave()
{
try
{
// Creating and initializing the network related objects.
TcpClient tcpC = new TcpClient(regSrvIP.AddressFamily);
tcpC.Connect(regSrvIP, regSrvPort);
NetworkStream netStream = tcpC.GetStream();
BinaryFormatter bf = new BinaryFormatter();
// Building the message to be sent to RegistrarServer (MessageType: Leave)
RegisterMessage regMsg = new RegisterMessage(MessageType.Leave, joiningMulticastEP.Address, joiningMulticastEP.Port, refSrvCookie);
// Sending the message request object to the RegistrarSErver
bf.Serialize(netStream, regMsg);
// Receiving the message response object from the RegistrarServer
Object obj = bf.Deserialize(netStream);
regMsg = (RegisterMessage)obj;
// Closing the server connection
tcpC.Close();
}
catch (Exception e)
{
eventLog.WriteEntry("Leave request to server " + regSrvIP + ":" + regSrvPort +
"for " + joiningMulticastEP + " failed. \n" + e.ToString(), System.Diagnostics.EventLogEntryType.Error, (int)RtpEL.ID.ReflectorJoinFailed);
}
}
public void Parse_XMLString_RegisterMessage()
{
/*********** Actual message ***********/
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"xml_samples\Register.xml");
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(path);
string xmlStr = xmlDoc.OuterXml;
string name = Message.GetMessageName(xmlStr);
RegisterMessage actualMessage = null;
if (name == RegisterMessage.ELEMENT_NAME)
{
actualMessage = RegisterMessage.Construct(xmlStr);
}
/*********** Expected message ***********/
RegisterType type = RegisterType.TaskManager;
byte threads = 3;
string[] problems = { "TSP", "GraphColoring" };
RegisterMessage expectedMessage = new RegisterMessage(type, threads, problems);
expectedMessage.Deregister = true;
expectedMessage.Id = 5;
Assert.AreEqual(expectedMessage, actualMessage);
}
private bool registerExistingNode(RegisterMessage message, Socket socket)
{
NetworkNode node = new NetworkNode(message.Type, message.Id, (uint)systemTracker.Timeout, message.ParallelThreads, message.SolvableProblems,
clientTracker.BackupServers);
IPAddress address = (socket.RemoteEndPoint as IPEndPoint).Address;
int port = (ushort)Server.PRIMARY_PORT;
// TODO hack
if (clientTracker.BackupServers.Length == 1)
{
port = (ushort)Server.PRIMARY_PORT2;
}
node.Address = address;
node.Port = (ushort)port;
// Dont inform backup about it self
// It comes naturally in NoOperation message
if (node.Type == RegisterType.CommunicationServer &&
(server.Address.ToString().Equals(address.ToString()) && server.Port == port))
{
return(false);
}
SmartConsole.PrintLine("Backup adding existing node", SmartConsole.DebugLevel.Advanced);
clientTracker.AddNode(node);
return(true);
}
public static void ForceLeave(ClientEntry client)
{
RegisterMessage leaveMessage = new RegisterMessage(MessageType.Leave,
client.GroupEP.Address, client.GroupEP.Port, client.ConfirmNumber);
ProcessLeaveRequest(leaveMessage, client.ClientIP);
}
public void RegistrationMessageIsAcceptedAndRegisterResponseMessageIsPassedBack()
{
var waitHandle = new AutoResetEvent(false);
var msg = new RegisterMessage
{
ParallelThreads = 5,
SolvableProblems = new List <string> {
"dvrp"
},
ComponentType = ComponentType.ComputationalNode
};
var rawMsg = _marshaller.Marshall(new Message[] { msg });
Message outputMessage = null;
ProcessedDataCallback c = response =>
{
outputMessage = _marshaller.Unmarshall(response)[0];
waitHandle.Set();
};
_processor.StartProcessing();
_processor.EnqueueDataToProcess(rawMsg, null, c);
waitHandle.WaitOne(10000);
_processor.StopProcessing();
Assert.IsInstanceOfType(outputMessage, typeof(RegisterResponseMessage));
}
public void RegistrationMessageIsAcceptedAndItsCallbackInvoked()
{
var waitHandle = new AutoResetEvent(false);
var callbackCalled = false;
var msg = new RegisterMessage
{
ComponentType = ComponentType.TaskManager,
ParallelThreads = 5,
SolvableProblems = new List <string> {
"dvrp"
}
};
var rawMsg = _marshaller.Marshall(new Message[] { msg });
ProcessedDataCallback c = response =>
{
callbackCalled = true;
waitHandle.Set();
};
_processor.StartProcessing();
_processor.EnqueueDataToProcess(rawMsg, null, c);
waitHandle.WaitOne(5000);
_processor.StopProcessing();
Assert.IsTrue(callbackCalled);
}
/// <summary>
/// Register user in database and return his token for api calls.
/// </summary>
/// <param name="username"></param>
/// <param name="password"></param>
/// <param name="facebookId"></param>
/// <returns></returns>
public string Register(string username, string password, string facebookId = "")
{
var message = new RegisterMessage()
{
FacebookId = facebookId,
Username = username,
Password = password
};
var httpResponse = HttpRequestHelper.PostObjectAsync(Endpoint + "/register", message).Result;
var body = HttpRequestHelper.GetContent(httpResponse).Result;
var statusCode = HttpRequestHelper.GetStatusCode(httpResponse);
if (statusCode != HttpStatusCode.OK)
{
throw new Exception(body);
}
// setup token
var token = JsonConvert.DeserializeObject <string>(body);
if (!string.IsNullOrWhiteSpace(token))
{
UserToken.Token = token;
}
return(token);
}
public async Task <ActionResult <RegisterMessage> > CreateMessage([FromBody] RegisterMessage message)
{
RegisterMessage result = this.Manager.CreateMessage(message, this.Identity);
await this.HubContext.Clients.AllExcept(new string[] { this.Identity.ID }).SendAsync("onNewMessage", result);
return(this.Ok(result));
}
protected override bool _GetPlayerInfo(NetworkReader reader, int connectionId, out short type, out int roomIndex, out int playerIndex)
{
type = 0;
roomIndex = -1;
playerIndex = -1;
if (__roomMap == null)
{
return(false);
}
RegisterMessage message = reader == null ? null : reader.ReadMessage <RegisterMessage>();
if (message == null)
{
return(false);
}
Room room;
if (!__roomMap.TryGetValue(message.roomName, out room) || room == null)
{
return(false);
}
if (__playerMap == null)
{
__playerMap = new Dictionary <string, Player>();
}
Player player;
if (!__playerMap.TryGetValue(message.name, out player))
{
if (!room.isRunning && GetCount(room.index) > 3)
{
return(false);
}
player.index = GetRoomNextIndex(room.index);
player.roomName = message.roomName;
__playerMap.Add(message.name, player);
if (__playerNames == null)
{
__playerNames = new Pool <string>();
}
__playerNames.Insert(nextNodeIndex, message.name);
}
type = (short)(player.index >= 0 && player.index < 4 ? (player.index + 4 - room.dealerIndex) & 3 : 4);
roomIndex = room.index;
playerIndex = player.index;
return(true);
}
public void Receive(Message msg)
{
if (!Connected)
{
return;
}
if (msg is AuthMessage authmsg)
{
if (Authed) //Someone tried to auth twice?
{
return;
}
Character = new Character
{
Client = this,
Name = authmsg.Mail
};
Send(new AuthConfirmMessage());
Send(new GMChangedMessage {
IsGM = true
});
Send(new TimeTurnMessage {
Time = DateTime.UtcNow, TurnEnd = DateTime.UtcNow.AddHours(1)
});
Authed = true;
return;
}
else if (msg is RegisterMessage)
{
RegisterMessage regMsg = (RegisterMessage)msg;
UserModel registeredUser = new UserModel(regMsg.Mail, regMsg.Password);
if (Server.RegisterUser(registeredUser))
{
Send(new RegisterResponeMessage {
Response = RegisterResponse.Ok
}); //TODO: Get a db
}
else
{
Send(new RegisterResponeMessage {
Response = RegisterResponse.NameTaken
});
}
}
if (!Authed)
{
return;
}
if (msg is SpeechMessage speechmsg)
{
Character.Speak(speechmsg.Text);
}
}
private RegisterMessage CreateRegisterMessage(ref Register register)
{
RegisterMessage message = new RegisterMessage(base.messageVersion, ref register);
if (register.SupportingToken != null)
{
CoordinationServiceSecurity.AddSupportingToken(message, register.SupportingToken);
}
return message;
}
public async Task <RegisterResponse> Register(RegisterMessage authorizeMessage)
{
var result = await HttpNetworkService.Post(
JsonDecoder.Serialize(authorizeMessage),
string.Concat(baseLobbyUrl, NetworkConfig.RegisterUrl)
);
return(new RegisterResponse());
}
private void WSConnected(object sender, EventArgs e)
{
RegisterMessage registerMessage = new RegisterMessage();
registerMessage.roomId = this.m_roomId;
registerMessage.signalingKey = this.m_signalingKey;
Debug.Log("Signaling: WS connected.");
this.WSSend(JsonUtility.ToJson(registerMessage));
}
/// <summary>
/// Gets RegisterMessage specified for this component.
/// </summary>
/// <returns>A proper RegisterMessage.</returns>
private RegisterMessage GetRegisterMessage()
{
var registerMessage = new RegisterMessage
{
ComponentType = ComponentType,
ParallelThreads = _threadManager.ParallelThreads,
SolvableProblems = new List <string>(TaskSolvers.Keys)
};
return(registerMessage);
}
public static void Regist(string user, string pass, string nickname)
{
var msg = new RegisterMessage()
{
Name = user,
NickName = nickname,
Pass = pass,
};
MessageManager.SendMessage("Client.Send", msg);
}
public async void Register (string deviceId, Guid multiplayerChallengeId)
{
try {
var registerMsg = new RegisterMessage (deviceId, multiplayerChallengeId);
string message = JsonConvert.SerializeObject (registerMsg, jsonSerializerSettings);
await connectionService.Send (message);
Debug.WriteLine ("sent register message: " + message);
} catch (Exception e) {
Debug.WriteLine ("registering failed: " + e.Message);
}
}
public void Register()
{
var msg = new RegisterMessage("Username", "Password");
Assert.AreEqual("Username", msg.Username);
Assert.AreEqual("Password", msg.Password);
msg = msg.AssertLengthMatches();
Assert.AreEqual("Username", msg.Username);
Assert.AreEqual("Password", msg.Password);
}
public void Register(string v, Deck deck)
{
if (RegistrationSent)
{
return;
}
RegistrationSent = true;
var registerMessage = new RegisterMessage(v, deck);
Send(new NetworkMessage(MessageTypes.RegisterForGame, registerMessage, Player.Id, NetworkId.Generate()));
}
public async Task Register()
{
var registerMsg = new RegisterMessage();
registerMsg.challengeId = challengeId;
registerMsg.deviceId = deviceId;
var registerMessage = new MessageFrame("register", registerMsg);
string message = JsonConvert.SerializeObject(registerMessage);
await connection.SendAsync(message);
Debug.WriteLine("sent register message: " + message);
}
/// <summary>
/// registers the component to server
/// </summary>
/// <param name="endpoint"></param>
public void Register(IPEndPoint endpoint)
{
_tcpClient.Connect(endpoint);
var listen = new Thread(ListenForMessages);
listen.Start();
var msg = new RegisterMessage(Type, MaxParallelThreads, SolvableProblems);
SendMessage(msg.Serialize());
}
public void RegisterMessageDeserializationTest()
{
var problemList = new List <string>()
{
"DVRP"
};
var registerMessage = new RegisterMessage(EComponentType.TaskManager, 1, problemList);
var result = Message.Deserialize <RegisterMessage>(registerMessage.SerializeToXml());
Assert.AreEqual("DVRP", result.SolvableProblems[0]);
}
private static RegisterMessage ProcessLeaveRequest(RegisterMessage leaveRequestMessage, IPAddress senderIP)
{
try
{
lock (clientRegTable.SyncRoot)
{
if (clientRegTable.ContainsKey(senderIP))
{
bool drop = true;
clientRegTable.Remove(senderIP);
ReflectorMgr.PC[ReflectorPC.ID.CurrentParticipats] = clientRegTable.Count;
// Drop membership if no other member exists
foreach (ClientEntry entry in clientRegTable.Values)
{
if (entry.GroupEP.Address.Equals(leaveRequestMessage.groupIP))
{
drop = false;
break;
}
}
if (drop)
{
if (leaveRequestMessage.groupIP.AddressFamily == AddressFamily.InterNetwork)
{
MulticastOption mo = new MulticastOption(leaveRequestMessage.groupIP, ReflectorMgr.MulticastInterfaceIP);
ReflectorMgr.Sockets.SockMCv4RTP.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.DropMembership, mo);
ReflectorMgr.Sockets.SockMCv4RTCP.SetSocketOption(SocketOptionLevel.IP, SocketOptionName.DropMembership, mo);
}
else
{
IPv6MulticastOption mo = new IPv6MulticastOption(leaveRequestMessage.groupIP);
ReflectorMgr.Sockets.SockMCv6RTP.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.DropMembership, mo);
ReflectorMgr.Sockets.SockMCv6RTCP.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.DropMembership, mo);
}
}
return(new RegisterMessage(MessageType.Confirm, leaveRequestMessage.groupIP, leaveRequestMessage.groupPort, leaveRequestMessage.confirmNumber));
}
else
{ // No entries found for the leave request
return(new RegisterMessage(MessageType.LeaveWithoutJoinError, IPAddress.Any));
}
}
}
catch
{
return(new RegisterMessage(MessageType.UnknownError, IPAddress.Any));
}
}
/// <summary>
/// Constructs message by given xml string
/// </summary>
/// <param name="xmlString">
/// xml in string
/// </param>
/// <returns>
/// Message constructed by the xml
/// </returns>
public static Message Construct(string xmlString)
{
xmlString = concCompabilityIssuesStringWojtekIsGay(xmlString);
if (GetMessageName(xmlString) == RegisterMessage.ELEMENT_NAME)
{
return(RegisterMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == DivideProblemMessage.ELEMENT_NAME)
{
return(DivideProblemMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == NoOperationMessage.ELEMENT_NAME)
{
return(NoOperationMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == RegisterResponseMessage.ELEMENT_NAME)
{
return(RegisterResponseMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == SolutionRequestMessage.ELEMENT_NAME)
{
return(SolutionRequestMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == SolutionsMessage.ELEMENT_NAME)
{
return(SolutionsMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == SolvePartialProblemsMessage.ELEMENT_NAME)
{
try
{
//return SolvePartialProblemsMessage.Construct(xmlString);
}
catch (InvalidOperationException e) { return(null); }
Console.WriteLine("******** SOLVE PARTIAL PROBLEM MESSAGE **************");
return(SolvePartialProblemsMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == SolveRequestMessage.ELEMENT_NAME)
{
return(SolveRequestMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == SolveRequestResponseMessage.ELEMENT_NAME)
{
return(SolveRequestResponseMessage.Construct(xmlString));
}
if (GetMessageName(xmlString) == StatusMessage.ELEMENT_NAME)
{
return(StatusMessage.Construct(xmlString));
}
return(null);
}
public static RegisterMessage CreateRegisterMessage()
{
RegisterType type = RegisterType.TaskManager;
byte threads = 3;
string[] problems = { "TSP", "GraphColoring" };
RegisterMessage expectedMessage = new RegisterMessage(type, threads, problems);
expectedMessage.Deregister = true;
expectedMessage.Id = 5;
return(expectedMessage);
}
public async Task <IActionResult> Post([FromBody] RegisterMessage command)
{
Customer customer = await register.Handle(command);
CustomerData result = new CustomerData
{
CustomerId = customer.Id,
Name = customer.Name.Text,
Personnummer = customer.PIN.Text
};
return(CreatedAtRoute("GetCustomer", new { id = result.CustomerId }, result));
}
public async Task<bool> Register(RegisterMessage message)
{
bool retval = false;
var info = await HttpContext.Authentication.GetAuthenticateInfoAsync(Constants.PrimaryAuthenticationType);
var sub = info.Principal.Claims.Where(x => x.Type == JwtClaimTypes.Subject).Select(x => x.Value).FirstOrDefault();
var user = _signInService.FindBySubject(sub);
if (user == null || message.PublicKey == null)
{
return false;
}
try
{
SHA256 hashalg = SHA256.Create();
byte[] publicKeyHashBuffer = hashalg.ComputeHash(Encoding.UTF8.GetBytes(message.PublicKey));
string publicKeyHash = Convert.ToBase64String(publicKeyHashBuffer);
retval = _credentialService.RegisterCredential(message.UserId, message.PublicKey, publicKeyHash, message.DeviceName);
}
catch (Exception)
{ }
return retval;
}
