/// <summary>
/// Run the report.
/// </summary>
/// <param name="reportRunner">
/// A <see cref="IReportRunner{TReportResult}"/> to run the report. This cannot be null.
/// </param>
/// <param name="reportResultFormatter">
/// A <see cref="IReportResultFormatter{TReportResult}"/> to format the report results. This cannot be null.
/// </param>
/// <param name="credentialRepository">
/// Used to load previously saved credentials. Cannot be null.
/// </param>
/// <param name="options">
/// The command line options. Cannot be null.
/// </param>
/// <returns>
/// The process return value.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="reportRunner"/>, <paramref name="reportResultFormatter"/>, <paramref name="credentialRepository"/>
/// and <paramref name="options"/> cannot be null.
/// </exception>
private static int RunReport <TReportResult>(IReportRunner <TReportResult> reportRunner, IReportResultFormatter <TReportResult> reportResultFormatter,
ICredentialRepository credentialRepository, CheckmarxReportOptions options)
{
if (reportRunner == null)
{
throw new ArgumentNullException(nameof(reportRunner));
}
if (reportResultFormatter == null)
{
throw new ArgumentNullException(nameof(reportResultFormatter));
}
if (credentialRepository == null)
{
throw new ArgumentNullException(nameof(credentialRepository));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
string userName;
string password;
GetCredentials(credentialRepository, options.Server, options.UserName, options.Password, out userName, out password);
using (Stream stream = string.IsNullOrWhiteSpace(options.OutputPath)
? Console.OpenStandardOutput() : new FileStream(options.OutputPath, FileMode.Create))
using (StreamWriter output = new StreamWriter(stream, Encoding.UTF8))
using (CheckmarxApiSession checkmarxApiSession = new CheckmarxApiSession(options.Server, userName, password))
{
reportResultFormatter.Format(reportRunner.Run(checkmarxApiSession, options), output, options, userName);
}
return(ExitSuccess);
}
public AuthenticationController(ILogger logger, ICorrelationIdHelper correlationIdHelper, IConfigurationManager configurationManager, IAuthenticationTokenHelper <Guid> authenticationTokenHelper, IQueryFactory queryFactory, ICredentialRepository credentialRepository, IAuthenticationHashHelper authenticationHashHelper)
: base(logger, correlationIdHelper, configurationManager, authenticationTokenHelper)
{
QueryFactory = queryFactory;
CredentialRepository = credentialRepository;
AuthenticationHashHelper = authenticationHashHelper;
}
public AgentManager(IAgentRepository agentRepository,
IScheduleRepository scheduleRepository,
IJobRepository jobRepository,
IAspNetUsersRepository usersRepository,
ICredentialRepository credentialRepository,
IAgentHeartbeatRepository agentHeartbeatRepository,
ApplicationIdentityUserManager userManager,
IPersonRepository personRepository,
IAgentGroupMemberRepository agentGroupMemberRepository,
IJobManager jobManager,
IWebhookPublisher webhookPublisher,
IHttpContextAccessor httpContextAccessor,
IAgentGroupRepository agentGroupRepository)
{
_agentRepo = agentRepository;
_scheduleRepo = scheduleRepository;
_jobRepo = jobRepository;
_usersRepo = usersRepository;
_credentialRepo = credentialRepository;
_agentHeartbeatRepo = agentHeartbeatRepository;
_userManager = userManager;
_personRepo = personRepository;
_agentGroupMemberRepository = agentGroupMemberRepository;
_jobManager = jobManager;
_agentGroupRepository = agentGroupRepository;
_webhookPublisher = webhookPublisher;
_caller = ((httpContextAccessor.HttpContext != null) ? httpContextAccessor.HttpContext.User : new ClaimsPrincipal());
}
/// <summary>
/// Instantiate a new instance of the <see cref="AuthenticationService"/> class.
/// </summary>
public AuthenticationService(IEventStore <Guid> eventStore, ILogger logger, ICorrelationIdHelper correlationIdHelper, IAuthenticationTokenHelper <Guid> authenticationTokenHelper, IQueryFactory queryFactory, ICredentialRepository credentialRepository, IAuthenticationHashHelper authenticationHashHelper, ICommandPublisher <Guid> commandPublisher)
: base(eventStore, logger, correlationIdHelper, authenticationTokenHelper)
{
CredentialRepository = credentialRepository;
QueryFactory = queryFactory;
AuthenticationHashHelper = authenticationHashHelper;
CommandPublisher = commandPublisher;
}
public void GivenIHaveACredentialRepository()
{
var utilityFactory = new XmlCredentialRepoBuilder {
EncryptionKey = _key
};
_credentialRepository = utilityFactory.BuildXmlCredentialRepo();
}
public UserRepository(ICredentialRepository credentialRepository,
IEmployeeRepository employeeRepository,
IPersonRepository personRepository)
{
_credentialRepository = credentialRepository;
_employeeRepository = employeeRepository;
_personRepository = personRepository;
}
public SessionQuery(IUserRepository repository, ICredentialRepository CreRepo,
IRestoreRepository ResRepo, IRoleRepository roleRepository)
{
_repository = repository;
_CreRepo = CreRepo;
_ResRepo = ResRepo;
_RoleRepo = roleRepository;
}
public CredentialService(ICredentialRepository iCredentialRepository)
{
if (iCredentialRepository == null)
{
throw new ArgumentNullException("ICredentialRepository Required");
}
_iCredentialRepository = iCredentialRepository;
}
public CredentialRepositoryChangedArgs(ICredentialRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
Repository = repository;
}
public CredentialTasks(ICredentialRepository credentialRepository,
IUserGroupTask userGroupTask,
IApplicationTask applicationTask,
IAuditTasks auditTasks)
{
this.credentialRepository = credentialRepository;
this.userGroupTask = userGroupTask;
this.applicationTask = applicationTask;
this.auditTasks = auditTasks;
}
public AgentManager(IAgentRepository agentRepository, IScheduleRepository scheduleRepository, IJobRepository jobRepository, IAspNetUsersRepository usersRepository,
ICredentialRepository credentialRepository, IAgentHeartbeatRepository agentHeartbeatRepository)
{
this.agentRepo = agentRepository;
this.scheduleRepo = scheduleRepository;
this.jobRepo = jobRepository;
this.usersRepo = usersRepository;
this.credentialRepo = credentialRepository;
this.agentHeartbeatRepo = agentHeartbeatRepository;
}
public void AddProvider(ICredentialRepository credentialProvider)
{
if (Contains(credentialProvider.Config.Id))
{
return;
}
_credentialProviders.Add(credentialProvider);
credentialProvider.CredentialsUpdated += RaiseCredentialsUpdatedEvent;
credentialProvider.RepositoryConfigUpdated += OnRepoConfigChanged;
RaiseRepositoriesUpdatedEvent(ActionType.Added, new[] { credentialProvider });
}
public UserManager(IHandler handler)
{
this.handler = handler;
this.permissionRepository = handler.Storage.GetRepository <IPermissionRepository>();
this.roleRepository = handler.Storage.GetRepository <IRoleRepository>();
this.rolePermissionRepository = handler.Storage.GetRepository <IRolePermissionRepository>();
this.userRepository = handler.Storage.GetRepository <IUserRepository>();
this.userRoleRepository = handler.Storage.GetRepository <IUserRoleRepository>();
this.credentialTypeRepository = handler.Storage.GetRepository <ICredentialTypeRepository>();
this.credentialRepository = handler.Storage.GetRepository <ICredentialRepository>();
}
public void RemoveProvider(ICredentialRepository credentialProvider)
{
if (!Contains(credentialProvider.Config.Id))
{
return;
}
credentialProvider.CredentialsUpdated -= RaiseCredentialsUpdatedEvent;
credentialProvider.RepositoryConfigUpdated -= OnRepoConfigChanged;
_credentialProviders.Remove(credentialProvider);
RaiseRepositoriesUpdatedEvent(ActionType.Removed, new[] { credentialProvider });
}
public CredentialsController(
ICredentialRepository repository,
IMembershipManager membershipManager,
ApplicationIdentityUserManager userManager,
ICredentialManager credentialManager,
IConfiguration configuration,
IHttpContextAccessor httpContextAccessor) : base(repository, userManager, httpContextAccessor, membershipManager, configuration)
{
this.httpContextAccessor = httpContextAccessor;
this.credentialManager = credentialManager;
this.credentialManager.SetContext(SecurityContext);
}
public DefaultUserManager(IHttpContextAccessor httpContextAccessor, IStorage storage)
{
this.httpContextAccessor = httpContextAccessor;
this.storage = storage;
this.permissionRepository = this.storage.GetRepository <IPermissionRepository>();
this.roleRepository = this.storage.GetRepository <IRoleRepository>();
this.rolePermissionRepository = this.storage.GetRepository <IRolePermissionRepository>();
this.userRepository = this.storage.GetRepository <IUserRepository>();
this.userRoleRepository = this.storage.GetRepository <IUserRoleRepository>();
this.credentialTypeRepository = this.storage.GetRepository <ICredentialTypeRepository>();
this.credentialRepository = this.storage.GetRepository <ICredentialRepository>();
}
public CredentialManager(ICredentialRepository repo,
IPersonRepository personRepository,
IAgentRepository agentRepository,
IOrganizationSettingRepository organizationSettingRepository,
IOrganizationManager organizationManager,
IConfiguration configuration)
{
_repo = repo;
_personRepository = personRepository;
_agentRepository = agentRepository;
_organizationSettingRepository = organizationSettingRepository;
_organizationManager = organizationManager;
_configuration = configuration;
}
/// <summary>
/// Use saved credentials if omitted.
/// </summary>
/// <param name="credentialRepository">
/// A <see cref="ICredentialRepository"/> to load saved credentials from.
/// </param>
/// <param name="server">
/// The server name. This cannot be null, empty or whitespace.
/// </param>
/// <param name="suppliedUserName">
/// The user name given on the command line. Use the stored one if null.
/// </param>
/// <param name="suppliedPassword">
/// The password given on the command line. Use the stored one if null.
/// </param>
/// <param name="userName">
/// Receives the user name.
/// </param>
/// <param name="password">
/// Received the password.
/// </param>
/// <exception cref="ArgumentException">
/// <paramref name="server"/> cannot be null, empty or whitespace.
/// </exception>
/// <exception cref="CredentialNotFoundException">
/// No credentials are specified or saved for that server.
/// </exception>
private static void GetCredentials(ICredentialRepository credentialRepository,
string server, string suppliedUserName, string suppliedPassword,
out string userName, out string password)
{
if (string.IsNullOrWhiteSpace(suppliedUserName) || string.IsNullOrWhiteSpace(suppliedPassword))
{
credentialRepository.Load(server, out userName, out password);
}
else
{
userName = suppliedUserName;
password = suppliedPassword;
}
}
public CredentialChangedEventArgs(ICredentialRecord credentialRecord, ICredentialRepository repository)
{
if (credentialRecord == null)
{
throw new ArgumentNullException(nameof(credentialRecord));
}
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
CredentialRecord = credentialRecord;
Repository = repository;
}
/// <summary>
/// CredentialsController constructor
/// </summary>
/// <param name="repository"></param>
/// <param name="membershipManager"></param>
/// <param name="userManager"></param>
/// <param name="credentialManager"></param>
/// <param name="configuration"></param>
/// <param name="httpContextAccessor"></param>
/// <param name="webhookPublisher"></param>
public CredentialsController(
ICredentialRepository repository,
IMembershipManager membershipManager,
ApplicationIdentityUserManager userManager,
ICredentialManager credentialManager,
IConfiguration configuration,
IHttpContextAccessor httpContextAccessor,
IWebhookPublisher webhookPublisher,
ICredentialRepository credentialRepository) : base(repository, userManager, httpContextAccessor, membershipManager, configuration)
{
_httpContextAccessor = httpContextAccessor;
_credentialManager = credentialManager;
_credentialManager.SetContext(SecurityContext);
_webhookPublisher = webhookPublisher;
_credentialRepository = credentialRepository;
}
public IndexViewModel Create(int userId, string orderBy, string direction, int skip, int take, string filter)
{
ICredentialRepository credentialRepository = this.RequestHandler.Storage.GetRepository <ICredentialRepository>();
return(new IndexViewModel()
{
UserId = userId,
Grid = new GridViewModelFactory(this.RequestHandler).Create(
orderBy, direction, skip, take, credentialRepository.CountByUserId(userId, filter),
new[] {
new GridColumnViewModelFactory(this.RequestHandler).Create("Credential Type"),
new GridColumnViewModelFactory(this.RequestHandler).Create("Identifier", "Identifier"),
new GridColumnViewModelFactory(this.RequestHandler).CreateEmpty()
},
credentialRepository.FilteredByUserIdRange(userId, orderBy, direction, skip, take, filter).ToList().Select(c => new CredentialViewModelFactory(this.RequestHandler).Create(c)),
"_Credential"
)
});
}
public IndexViewModel Build(int userId, string orderBy, string direction, int skip, int take)
{
ICredentialRepository credentialRepository = this.handler.Storage.GetRepository <ICredentialRepository>();
return(new IndexViewModel()
{
UserId = userId,
Grid = new GridViewModelBuilder(this.handler).Build(
orderBy, direction, skip, take, credentialRepository.CountByUserId(userId),
new[] {
new GridColumnViewModelBuilder(this.handler).Build("Credential Type"),
new GridColumnViewModelBuilder(this.handler).Build("Identifier", "Identifier"),
new GridColumnViewModelBuilder(this.handler).BuildEmpty()
},
credentialRepository.Range(userId, orderBy, direction, skip, take).Select(c => new CredentialViewModelBuilder(this.handler).Build(c)),
"_Credential"
)
});
}
/// <summary>
/// Save user credentials.
/// </summary>
/// <param name="credentialRepository">
/// The <see cref="ICredentialRepository"/> to save credentials to.
/// </param>
/// <param name="server">
/// The Checkmarx server name. Cannot be null, empty or whitespace.
/// </param>
/// <param name="userName">
/// The username to login with. Cannot be null, empty or whitespace.
/// </param>
/// <param name="password">
/// The password to login with. Cannot be null.
/// </param>
/// <returns>
/// The process return value.
/// </returns>
/// <exception cref="ArgumentException">
/// <paramref name="server"/>, <paramref name="userName"/> and <paramref name="password"/> cannot
/// be null, empty or whitespace.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="credentialRepository"/> cannot be null.
/// </exception>
private static int SaveCredentials(ICredentialRepository credentialRepository, string server, string userName, string password)
{
if (credentialRepository == null)
{
throw new ArgumentNullException(nameof(credentialRepository));
}
if (string.IsNullOrWhiteSpace(server))
{
throw new ArgumentException("Argument is null or whitespace", nameof(server));
}
if (string.IsNullOrWhiteSpace(userName))
{
throw new ArgumentException("Argument is null or whitespace", nameof(userName));
}
if (string.IsNullOrWhiteSpace(password))
{
throw new ArgumentException("Argument is null or whitespace", nameof(password));
}
credentialRepository.Save(server, userName, password);
return(ExitSuccess);
}
public IActionResult ResetPassword(ResetPasswordViewModel resetPassword)
{
ICredentialRepository credentialRepository = this.Storage.GetRepository <ICredentialRepository>();
if (this.ModelState.IsValid)
{
string newPassword = new Random().Next(10000000, 99999999).ToString();
UserManager.ChangeSecretResult changeSecretResult = new UserManager(this).ChangeSecret("Email", resetPassword.Email, newPassword);
if (changeSecretResult.Success)
{
this.emailSender.SendEmail(resetPassword.Email, "New password", newPassword, null);
return(this.RedirectToAction("PasswordSent"));
}
else
{
this.ModelState.AddModelError(nameof(resetPassword.Email), string.Empty);
}
}
return(this.CreateRedirectToSelfResult());
}
public CredentialService(ICustomFormsAuthentication customFormsAuthentication, IHashService hashService, ICredentialRepository credentialRepository)
{
this.CustomFormsAuthentication = customFormsAuthentication;
this.CredentialRepository = credentialRepository;
this.HashService = hashService;
}
public AddImageRequest(IWebRequestFactory webRequestFactory, ILogProvider logProvider, ICredentialRepository credentialRepository) : base(webRequestFactory, logProvider, credentialRepository)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SymmetricCrypto"/> class.
/// </summary>
/// <param name="credentialRepository">
/// An object that can retrieve <see cref="ICredential"/> objects.
/// </param>
/// <param name="encoding">
/// The <see cref="Encoding"/> that is used to convert a <c>string</c> object to a
/// <c>byte[]</c> value.
/// </param>
public SymmetricCrypto(ICredentialRepository credentialRepository,
Encoding encoding = null)
{
_credentialRepository = credentialRepository;
_encoding = encoding ?? Encoding.UTF8;
}
protected BaseRequest(IWebRequestFactory webRequestFactory, ILogProvider logProvider, ICredentialRepository credentialRepository)
{
_webRequestFactory = webRequestFactory;
_log = logProvider.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
_credentialRepository = credentialRepository;
}
public void AddRepository(ICredentialRepository repository)
{
_repositoryList.AddProvider(repository);
}
public void RemoveRepository(ICredentialRepository repository)
{
_repositoryList.RemoveProvider(repository);
}
public CredentialManager(ICredentialRepository repo)
{
this.repo = repo;
}
public TestRequest(IWebRequestFactory webRequestFactory, ILogProvider logProvider, ICredentialRepository credentialRepository)
: base(webRequestFactory, logProvider, credentialRepository)
{
}
public UserController(ICredentialRepository credRepo, ILogger <UserController> logger)
{
_credRepo = credRepo;
_logger = logger;
}
public ReportController(ICredentialRepository credentialRepository)
{
_CredentialRepository = credentialRepository;
}
