XK0-005 Exam Dumps - CompTIA Linux+ Questions and Answers

The command that will provide the correct information about whether files from the wget package have been altered since they were installed is rpm -V wget. This command will use the rpm utility to verify an installed RPM package by comparing information about the installed files with information from the RPM database. The verification process can check various attributes of each file, such as size, mode, owner, group, checksum, capabilities, and so on. If any discrepancies are found, rpm will report them using a single letter code for each attribute.

The other options are not correct commands for verifying an installed RPM package. The rpm -i wget command is invalid because -i is used to install a package from a file, not to verify an installed package. The rpm -qf wget command will query which package owns wget as a file name or path name, but it will not verify its attributes. The rpm -F wget command will freshen (upgrade) an already installed package with wget as a file name or path name, but it will not verify its attributes. References: rpm(8) - Linux manual page; Using RPM to Verify Installed Packages

The ~/.ssh/authorized_keys file contains SSH public keys that grant access to the user account. Removing this file ensures that no external entities can log in using previously authorized keys. The ~/.ssh/known_hosts file stores fingerprints of previously connected hosts. Removing this file ensures that SSH doesn't trust any previously connected hosts.

Part 1

Here is the step-by-step command construction process:

1. Move the private key (likely named server1 based on the provided details) to the .ssh directory:

mv ~/server1 ~/.ssh/id_rsa

This command moves the private key (assuming it's named server1) from the home directory (~) to the .ssh directory and renames it to id_rsa (which is the default SSH private key file name).

2. Set the correct permissions for the private key file:

chmod 600 ~/.ssh/id_rsa

The private key file should be readable and writable only by the owner to maintain security.

3. Connect to the server using the private key and the correct port (2222):

ssh -i ~/.ssh/id_rsa -p 2222 admin@server1

This command tells ssh to use the specified private key (-i ~/.ssh/id_rsa), connect on port 2222 (-p 2222), and log in as the admin user on server1.

Part 2: Setting File Permissions

The correct command to set the file permissions based on the screenshots would likely involve using chmod. Here is the command to set permissions correctly:

chmod 600 ~/.ssh/id_rsa

This restricts the private key's permissions so that only the user can read and write it.

Part 3: Setting Ownership

If ownership needs to be set, the command would look like this:

chown comptia:comptia ~/.ssh/id_rsa

This command ensures that the file is owned by the correct user (comptia) and the correct group (comptia).

In part 4, it asks you to select the proper file for editing to enable remote server access. Based on standard SSH configuration requirements, the proper file to edit for remote server access would be ~/.ssh/config.

Here’s why:

~/.ssh/config: This file allows you to set up configuration options for different hosts, including specifying ports, user names, and the identity file (private key). You would add the necessary configuration for server1 to this file for easier access.

Other options:

~/.ssh/authorized_keys: This file lists public keys that are authorized to log in to the local system. It's not meant for configuring remote access to another server.

~/.ssh/known_hosts: This file stores the host keys of servers you’ve connected to. It doesn’t allow for editing remote access settings.

~/.ssh/server1: This seems like a private key file or another custom file, but it’s not typically used to configure SSH options.

For configuring access to server1 on port 2222, you would add a block like this to the ~/.ssh/config file:

Host server1

HostName server1

Port 2222

User admin

IdentityFile ~/.ssh/id_rsa

Running a command with & at the end sends it to the background, allowing the administrator to continue using the terminal for other tasks while the script runs. This is useful for long-running scripts that do not require immediate attention but need to keep running.

The .gitignore file is used in Git to specify which files or directories should be ignored in a repository. By listing configuration files in the .gitignore file, the administrator ensures they are not included in any future commits or pushes to the remote repository. This is essential when dealing with sensitive or environment-specific files that should not be shared or deployed.

After modifying a user’s group membership with usermod -aG, the changes do not take effect until logout/login (or new session).

A is correct: Logging out and in refreshes group membership.

Incorrect Options:

B: Group has write permission already.

C: source doesn’t apply to /etc/group; it’s a shell command.

D: User already has the needed group permission.

The correct answer is D. git checkout -b staging

This command will create a new branch named staging and switch to it. The git checkout command is used to switch between branches or restore files from a specific branch. The -b option is used to create a new branch if it does not exist. For example, git checkout -b staging will create and switch to the staging branch.

The other options are incorrect because:

A. git branch -m staging

This command will rename the current branch to staging, not switch to it. The git branch command is used to list, create, or delete branches. The -m option is used to rename a branch. For example, git branch -m staging will rename the current branch to staging.

B. git commit -m staging

This command will commit the changes in the working tree to the current branch with a message of staging, not switch to it. The git commit command is used to record changes to the repository. The -m option is used to specify a commit message. For example, git commit -m staging will commit the changes with a message of staging.

C. git status -b staging

This command will show the status of the working tree and the current branch, not switch to it. The git status command is used to show the state of the working tree and the staged changes. The -b option is used to show the name of the current branch. However, this option does not take an argument, so specifying staging after it will cause an error.

To monitor logs in real-time, the tail -f command is used. This tells the system to “follow” the file as new lines are added—an essential tool for observing logs like /var/log/messages, /var/log/syslog, or application logs.

Option A is correct: tail -f actively watches the file and prints new lines as they are written.

Option B simply forces the filename to print—irrelevant in this context.

Option C requires a byte count and does not monitor real-time changes.

Option D shows the last 10 lines, but doesn’t continue monitoring.

A is correct: Appending & runs the script in the background, allowing the user to continue using the terminal.

Incorrect Options:

B: Executes in the current shell, not background.

C: Invalid use of jobs.

D: Changes priority but still runs in foreground.