public static RelayResponse ResetPassword(RelayMessage message) { var credential = Utils.ConvertDynamic <PasswordReset>(message.Data); var res = new RelayResponse { Operation = SiteOperation.ResetPW, OriginConnectionId = message.OriginConnectionId, Identifier = message.Identifier, OriginSiteId = message.OriginSiteId, Data = credential.UserName }; var user = GetUserPrincipal(credential.UserName); user.SetPassword(credential.NewPassword); user.Save(); if (credential.Unlock) { user.UnlockAccount(); user.Save(); } if (credential.SetChangePasswordAtNextLogon) { user.ExpirePasswordNow(); } return(res); }
public static RelayResponse SetUserStatus(ADUser user) { var res = new RelayResponse { Operation = SiteOperation.SetUserStatus }; try { UserPrincipal userPrincipal = GetUserPrincipal(user.OrgSamAccountName); userPrincipal.Enabled = user.Enabled; userPrincipal.AccountExpirationDate = user.AccountExpirationDate; userPrincipal.PasswordNeverExpires = user.PasswordNeverExpires; userPrincipal.SmartcardLogonRequired = user.SmartcardLogonRequired; userPrincipal.UserCannotChangePassword = user.UserCannotChangePassword; if (user.OrgSamAccountName != user.SamAccountName) { userPrincipal.SamAccountName = user.SamAccountName; } userPrincipal.Save(); return(res); } catch (Exception ex) { res.Success = false; res.ErrorMessage = ex.Message; return(res); } }
public static RelayResponse GetUserStatus(string localGuid) { var res = new RelayResponse { Operation = SiteOperation.GetUserStatus }; try { UserPrincipal p = GetUserPrincipal(localGuid); var usr = new ADUser { AccountExpirationDate = p.AccountExpirationDate, AccountLockoutTime = p.AccountLockoutTime, BadLogonCount = p.BadLogonCount, Enabled = p.Enabled, LastBadPasswordAttempt = p.LastBadPasswordAttempt, LastLogon = p.LastLogon, LastPasswordSet = p.LastPasswordSet, PasswordNeverExpires = p.PasswordNeverExpires, SamAccountName = p.SamAccountName, SmartcardLogonRequired = p.SmartcardLogonRequired, UserCannotChangePassword = p.UserCannotChangePassword }; res.Data = usr; return(res); } catch (Exception ex) { res.Success = false; res.ErrorMessage = ex.Message; return(res); } }
public static async Task <RelayResponse> GetUserStatus(StagedUser user) { try { var client = new SigRClient(Settings.AdminSiteUrl, Settings.STSApiKey, "SiteHub"); var msg = new RelayMessage { ApiKey = Settings.AdminApiKey, Data = user.LocalGuid, DestSiteId = user.SiteId, Identifier = user.Upn, Operation = SiteOperation.GetUserStatus }; await client.StartAsync(); RelayResponse res = await client.ProcessRelayMessage(msg); return(res); } catch (Exception ex) { Utils.AddLogEntry("Error getting user status", EventLogEntryType.Error, 0, ex); return(new RelayResponse { Success = false, ErrorMessage = ex.Message }); } }
public static async Task <RelayResponse> ResetPassword(PasswordReset credential, StagedUser stagedUser) { try { var client = new SigRClient(Settings.AdminSiteUrl, Settings.STSApiKey, "SiteHub"); var data = JsonConvert.SerializeObject(credential); var msg = new RelayMessage { ApiKey = Settings.AdminApiKey, Data = data, DestSiteId = stagedUser.SiteId, Identifier = stagedUser.Id, Operation = SiteOperation.ResetPW }; await client.StartAsync(); RelayResponse res = await client.ProcessRelayMessage(msg); return(res); } catch (Exception ex) { Utils.AddLogEntry("Error setting user status", EventLogEntryType.Error, 0, ex); return(new RelayResponse { Success = false, ErrorMessage = ex.Message }); } }
/// <summary> /// Executed when response for a request is sent back. /// </summary> /// <param name="requestId">Unique request Id.</param> /// <param name="relayResponse">The response being sent back.</param> /// <returns>Task tracking operation.</returns> public Task ResponseSentAsync(string requestId, RelayResponse relayResponse) { this.Dispatcher.Invoke(() => { this.logger.LogTrace("Updating request with Id '{0}'", requestId); if (this.requestMap.ContainsKey(requestId)) { try { RequestDetails requestDetails = this.requestMap[requestId]; requestDetails.ResponseData = this.GetUIFriendlyString(relayResponse.OutputStream, relayResponse.Headers[HttpResponseHeader.ContentType], relayResponse.Headers[HttpResponseHeader.ContentEncoding]); requestDetails.ResponseHeaders = relayResponse.Headers.GetHeaderMap(); requestDetails.StatusCode = relayResponse.HttpStatusCode.ToString(); requestDetails.Duration = (relayResponse.RequestEndDateTime.DateTime - requestDetails.RequestReceiveTime).TotalMilliseconds + " ms"; // For a Change event to fire we need to completely replace the object so we are cloning the object and replacing it. this.requestMap[requestId] = JObject.FromObject(requestDetails).ToObject <RequestDetails>(); } catch (Exception ex) { this.logger.LogWarning(ex, "Hit exception while updating request with Id '{0}'.", requestId); } } }); return(Task.CompletedTask); }
private Nethereum.Signer.Transaction ConvertToTx(RelayResponse response) { var tx = new Nethereum.Signer.Transaction( response.To, response.Value.Value, response.Nonce.Value, response.GasPrice.Value, response.Gas.Value, response.Input); tx.SetSignature(new EthECDSASignature( new Org.BouncyCastle.Math.BigInteger(response.R.RemoveHexPrefix(), 16), new Org.BouncyCastle.Math.BigInteger(response.S.RemoveHexPrefix(), 16), response.V.HexToByteArray())); return(tx); }
public static Transaction ToTransaction(this RelayResponse response) { var tx = new Transaction( response.To, response.Value.Value, response.Nonce.Value, response.GasPrice.Value, response.Gas.Value, response.Input); tx.SetSignature(new EthECDSASignature( new Org.BouncyCastle.Math.BigInteger(response.R.RemoveHexPrefix(), 16), new Org.BouncyCastle.Math.BigInteger(response.S.RemoveHexPrefix(), 16), response.V.HexToByteArray())); return(tx); }
public static RelayResponse EnableDisableUser(string username, bool enabled) { var res = new RelayResponse(); try { UserPrincipal userPrincipal = GetUserPrincipal(username); userPrincipal.Enabled = enabled; userPrincipal.Save(); return(res); } catch (Exception ex) { res.Success = false; res.ErrorMessage = ex.Message; return(res); } }
private void ValidateTx( RelayResponse returnedTx, TransactionInput transaction, BigInteger txFee, BigInteger gasPrice, BigInteger gasLimit, BigInteger nonce, string relayHubAddress, string relayAddress) { var tx = returnedTx.ToTransaction(); var signer = tx.Key.GetPublicAddress(); var functionEncodingService = new FunctionMessageEncodingService <RelayCallFunction>(); var relayCall = functionEncodingService.DecodeInput(new RelayCallFunction(), returnedTx.Input); var returnedTxHash = GetTransactionHash( relayCall.From, relayCall.To, relayCall.EncodedFunction.ToHex(), relayCall.TransactionFee, relayCall.GasPriceParam, relayCall.GasLimit, relayCall.NonceParam, returnedTx.To, signer); var hash = GetTransactionHash( transaction.From, transaction.To, transaction.Data, txFee, transaction.GasPrice.Value, transaction.Gas.Value, nonce, relayHubAddress, relayAddress); if (returnedTxHash.EnsureHexPrefix().ToLower() != hash.EnsureHexPrefix().ToLower() || signer.EnsureHexPrefix().ToLower() != relayAddress.EnsureHexPrefix().ToLower()) { throw new GSNRelayInvalidResponseException(); } }
public static RelayResponse GetScriptVersion(RelayMessage message) { var res = new RelayResponse(); try { var dir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); var path = Path.GetFullPath(string.Format("{0}\\Scripts\\ScriptVersion.txt", dir)); res.Data = File.ReadAllText(path); res.Success = true; return(res); } catch (Exception ex) { res.Success = false; res.ErrorMessage = ex.Message; return(res); } }
/// <summary> /// Processes an event when response is sent. /// </summary> /// <param name="requestId">Unique Id of the request.</param> /// <param name="relayResponse">Relay response.</param> /// <returns>Task tracking operation.</returns> public Task ResponseSentAsync(string requestId, RelayResponse relayResponse) { lock (this.lockObject) { RequestConsoleDetails requestConsoleDetails = this.requestConsoleDetailsMap[requestId]; this.requestConsoleDetailsMap.Remove(requestId); Console.SetCursorPosition( 0, requestConsoleDetails.RequestConsoleTopCursor + 1); Console.Write(string.Format( CultureInfo.InvariantCulture, " -----> {0} - {1}", relayResponse.HttpStatusCode.ToString(), (DateTime.Now - requestConsoleDetails.RequestStartTime).TotalMilliseconds)); Console.WriteLine(); } return(Task.CompletedTask); }
/// <summary> /// Site will reset the ADUser password from the admin portal /// </summary> /// <param name="credential"></param> private static void LogPWReset(RelayResponse response) { SyncLogEntry log; if (response.Success) { log = new SyncLogEntry( EventLogEntryType.SuccessAudit, string.Format("Password was reset for {0}", response.Data), "SiteAgent.SiteOp.ResetPW", response.Identifier); } else { log = new SyncLogEntry( EventLogEntryType.FailureAudit, string.Format("Password reset failed for {0} (error: {1})", response.Data, response.ErrorMessage), "SiteAgent.SiteOp.ResetPW", response.Identifier); } OrgApiCalls.AddSyncLog(log); }
public static RelayResponse UpdateUser(StagedUser user) { var res = new RelayResponse { Operation = SiteOperation.UpdateUser }; try { var principal = GetUserPrincipal(user.Upn); principal.GivenName = user.GivenName; principal.Surname = user.Surname; principal.DisplayName = user.DisplayName; principal.Name = user.Name; principal.EmailAddress = user.Mail; principal.VoiceTelephoneNumber = user.TelephoneNumber; var de = (DirectoryEntry)principal.GetUnderlyingObject(); de.Properties["title"].Value = user.Title; de.Properties["streetAddress"].Value = user.StreetAddress; de.Properties["st"].Value = user.State; de.Properties["postalCode"].Value = user.PostalCode; de.Properties["mobile"].Value = user.Mobile; de.Properties["homePhone"].Value = user.HomePhone; de.Properties["department"].Value = user.Department; de.Properties["c"].Value = user.Country; de.Properties["l"].Value = user.City; de.CommitChanges(); principal.Save(); return(res); } catch (Exception ex) { res.Success = false; res.ErrorMessage = ex.Message; return(res); } }
/// <summary> /// Called by the responding site to send relay response back to the hub for forwarding to the requester /// </summary> /// <param name="res"></param> private void ForwardRelayResponse(RelayResponse response) { SendStatus("Calling forward relay response for {0} from {1}...", response.Operation.ToString(), response.OriginSiteId); _siteHubProxy.Invoke <RelayResponse>("ForwardRelayResponse", response); }
/// <summary> /// When a relay response is returned from a site, this method forwards the response back to the STS (which is also a relay client) /// </summary> /// <param name="response"></param> public void ForwardRelayResponse(RelayResponse response) { Clients.Client(response.OriginConnectionId).ProcessRelayResponse(response); }
private async Task <string> SendViaRelay( string relayUrl, TransactionInput transaction, BigInteger txFee, BigInteger gasPrice, BigInteger gasLimit, BigInteger nonce, string relayHubAddress, string relayAddress, string signature, string approvalData, BigInteger relayMaxNonce) { var requestData = new RelayRequest { EncodedFunction = transaction.Data, Signature = signature.HexToByteArray(), ApprovalData = approvalData.HexToByteArray(), From = transaction.From, To = transaction.To, GasPrice = gasPrice, GasLimit = gasLimit, RelayFee = txFee, RecipientNonce = nonce, RelayMaxNonce = relayMaxNonce, RelayHubAddress = relayHubAddress, UserAgent = _options.UserAgent }; RelayResponse relayResponse = await _relayClient.RelayAsync(new Uri(relayUrl), requestData) .ConfigureAwait(false); if (!string.IsNullOrEmpty(relayResponse.Error)) { throw new Exception(relayResponse.Error); } if (relayResponse.Nonce.Value.IsZero) { throw new Exception("Empty body received from server, or neither 'error' nor 'nonce' fields present."); } ValidateTx( relayResponse, transaction, txFee, gasPrice, gasLimit, nonce, relayHubAddress, relayAddress); var tx = relayResponse.ToTransaction(); string hash = string.Empty; var ethSendTransaction = new EthSendRawTransaction(_client); try { hash = await ethSendTransaction.SendRequestAsync(tx.GetRLPEncoded().ToHex().EnsureHexPrefix()) .ConfigureAwait(false); } catch (Exception ex) { if (!ex.Message.Contains("the tx doesn't have the correct nonce") && !ex.Message.Contains("known transaction") && !ex.Message.Contains("nonce too low")) { throw ex; } } var txHash = relayResponse.Hash; if (!string.IsNullOrEmpty(hash) && relayResponse.Hash.EnsureHexPrefix().ToLower() != hash.EnsureHexPrefix().ToLower()) { txHash = hash; } return(txHash); }