unit 6

1. What do you mean by Shell Script? Write a shell script program to find factorial of a given number.

A shell script is a program or script written in a scripting language that is interpreted by a shell, which is a command-line interface to an operating system. Shell scripts are used to automate tasks, execute commands, and perform various system operations. They are especially powerful for repetitive or batch processing tasks.

Here's a shell script in Bash to find the factorial of a given number:

#!/bin/bash

# Prompt the user for input
echo "Enter a number: "
read num

# Initialize factorial to 1
factorial=1

# Loop to calculate the factorial
while [ $num -gt 1 ]; do
    factorial=$((factorial * num))
    num=$((num - 1))
done

# Display the factorial
echo "Factorial is: $factorial"

Save this script to a file, e.g., factorial.sh. Make it executable using the following command:

chmod +x factorial.sh

You can then run the script:

./factorial.sh

2. What is crontab and explain its functionality and explain the format of crontab? What do you understand by CLI?

Crontab is a time-based job scheduler in Unix-like operating systems. It allows users to schedule tasks or jobs to run automatically at specified intervals or times. These scheduled tasks are referred to as "cron jobs." Crontab is a convenient way to automate routine system maintenance, backups, data synchronization, and other tasks without manual intervention.

Functionality of Crontab:

Scheduling: Crontab allows you to schedule jobs to run at specific times, dates, or intervals. You can specify daily, weekly, monthly, or custom schedules.
Automation: It automates repetitive tasks, reducing the need for manual intervention.
System Maintenance: You can use crontab to perform system maintenance, such as cleaning up log files, updating databases, or performing backups.
Notifications: Crontab can be used to send automated email notifications or alerts when specific conditions are met.
Custom Scripts: You can create custom shell scripts or commands and schedule them to run at desired times using crontab.

Format of Crontab: The crontab file has a specific format for specifying the schedule and the command to execute. Here's the basic format of a crontab entry:

* * * * * command_to_execute

The five asterisks represent the schedule, specifying when the job should run. They correspond to minutes, hours, days of the month, months, and days of the week, respectively.
command_to_execute is the actual command or script that you want to run.

Here's a breakdown of each field:

Minutes (0-59)
Hours (0-23)
Days of the Month (1-31)
Months (1-12 or names like "Jan," "Feb," etc.)
Days of the Week (0-6, where 0 represents Sunday, 1 represents Monday, and so on, or names like "Sun," "Mon," etc.)

For example, to schedule a job to run every day at 2:30 PM, the crontab entry would be:

30 14 * * * command_to_execute

CLI (Command Line Interface): A Command Line Interface (CLI) is a text-based user interface that allows users to interact with a computer or software by typing commands into a terminal or command prompt. In a CLI, users enter text commands to perform tasks, execute programs, configure settings, and access system resources.

Key characteristics of a CLI include:

Text-based: Users communicate with the system through text commands and receive text-based responses.
Efficiency: CLI users can perform tasks quickly by chaining commands and leveraging scripting.
Scripting and Automation: CLIs are well-suited for scripting and automating repetitive tasks.
Resource Efficiency: CLIs often consume fewer system resources than graphical interfaces.
Remote Access: CLIs are commonly used for remote server administration over SSH (Secure Shell).

3.For what we need backing-up and restoring features in operating system? Explain backing up strategies.

Backing up and restoring features in an operating system are essential for several reasons:

Data Protection: Backups are critical for protecting data from accidental deletion, hardware failures, file corruption, and other data loss scenarios. Without backups, valuable data can be permanently lost.
Disaster Recovery: In the event of a catastrophic failure, such as a system crash, natural disaster, or cyberattack, backups are crucial for recovering the entire system and its data to a previous state.
System Integrity: Backups can be used to restore the operating system and applications to a known working state. This helps maintain system integrity and ensures that the OS and software function correctly.
Version Control: Backups allow you to maintain multiple versions of files, which is useful for tracking changes and rolling back to previous versions if needed.
Data Migration: When upgrading hardware or transitioning to a new system, backups facilitate the transfer of data and configurations to the new environment.
Legal and Compliance Requirements: Many organizations are required by law or industry regulations to retain specific data for a certain period. Backups help meet these legal and compliance obligations.

Backup Strategies:

There are several backup strategies and methods to ensure data protection and recovery. Here are some common backup strategies:

Full Backup: A full backup copies all data and files from the source to the backup destination. It provides a complete snapshot of the data. While it ensures comprehensive recovery, it can be time-consuming and resource-intensive.
Incremental Backup: Incremental backups only copy the data that has changed since the last backup. They are faster and require less storage space than full backups but may require multiple backups to restore a specific point in time.
Differential Backup: Differential backups copy all data that has changed since the last full backup. While they are faster than full backups and require fewer backups for restoration than incrementals, they still consume more space than incrementals.
Continuous Data Protection (CDP): CDP continuously backs up data in real-time or at short intervals. It provides nearly instantaneous recovery to any point in time, but it can be resource-intensive.
Local and Offsite Backups: Storing backups locally and offsite provides redundancy and disaster recovery. Local backups are faster to access, while offsite backups protect against site-wide disasters.
Automated and Scheduled Backups: Regularly scheduled backups, often automated through backup software, ensure that backups are consistent and up to date.
Testing and Verification: Regularly test and verify backups to ensure they can be successfully restored when needed.
Encryption and Security: Secure backups with encryption to protect sensitive data during storage and transmission.
Versioning: Maintain multiple versions of files to recover from accidental changes or deletions.
Backup Rotation: Implement backup rotation strategies to manage storage and ensure a historical record of backups.

4. How can you make secure files in Linux? Explain.

Securing files in Linux involves implementing various measures to protect the confidentiality, integrity, and availability of sensitive data. Here are some ways to make files more secure in a Linux environment:

File Permissions:
- Use the chmod command to set appropriate file permissions. Restrict access to files by allowing only authorized users or groups to read, write, or execute them.
- Avoid using overly permissive permissions, such as "777" (read, write, and execute for everyone), unless absolutely necessary.
User and Group Ownership:
- Assign proper ownership of files using the chown command. Ensure that files are owned by the correct user or group.
- Limit access to sensitive files by placing them in directories owned by trusted users or groups.
Access Control Lists (ACLs):
- ACLs provide fine-grained control over file permissions. You can use setfacl and getfacl to manage ACLs.
- ACLs allow you to grant or deny specific permissions to individual users or groups beyond the traditional owner, group, and other permissions.
Encryption:
- Use encryption techniques to protect the contents of sensitive files. Tools like GPG (GNU Privacy Guard) can encrypt files and provide secure decryption methods.
Secure Copy (SCP):
- When transferring files over the network, use SCP or SFTP (SSH File Transfer Protocol) instead of insecure protocols like FTP. SCP encrypts file transfers.
File Integrity Checking:
- Implement file integrity checking mechanisms like Tripwire or use cryptographic checksums (e.g., SHA-256) to verify file integrity. Detect unauthorized changes to files.
Secure File Deletion:
- Use secure methods to delete sensitive files, such as shred or wipe, which overwrite file data before deletion to prevent recovery.
File System Security:
- Choose secure file systems like ext4, which provide features such as journaling to protect against data corruption.
- Consider using file system-level encryption like LUKS for entire partitions or drives.
User Authentication and Authorization:
- Ensure that users are authenticated and authorized before accessing sensitive files. Use strong authentication methods like SSH keys or two-factor authentication (2FA).
Audit Trails:
- Enable auditing and logging to monitor file access and changes. Tools like auditd can track file events and user actions.
Secure Backups:
- Protect backup files by securing the backup server, encrypting backup data, and implementing access controls on backup files.
Secure File Sharing:
- If files need to be shared, use secure file sharing mechanisms like Samba or NFS with proper authentication and access controls.
Regular Updates:
- Keep the Linux operating system and software up to date to patch security vulnerabilities that could affect file security.
Least Privilege Principle:
- Apply the principle of least privilege, which means giving users and processes only the minimum permissions necessary to perform their tasks.
Security Policies:
- Develop and enforce security policies that specify how files should be protected, accessed, and shared within your organization.
User Training:
- Educate users about security best practices, including the safe handling of sensitive files, password security, and social engineering awareness.

5.Write a shell script to find the largest among the four numbers.

#!/bin/bash

# Prompt the user to enter four numbers
echo "Enter four numbers, separated by spaces:"
read num1 num2 num3 num4

# Initialize a variable to store the largest number
largest=$num1

# Compare num2 with largest
if [ $num2 -gt $largest ]; then
  largest=$num2
fi

# Compare num3 with largest
if [ $num3 -gt $largest ]; then
  largest=$num3
fi

# Compare num4 with largest
if [ $num4 -gt $largest ]; then
  largest=$num4
fi

# Display the largest number
echo "The largest number is: $largest"

Save this script to a file, e.g., find_largest.sh, and make it executable using the following command:

chmod +x find_largest.sh

You can then run the script:

./find_largest.sh

6. What is Backup and Restore? Explain any two backup tools available in Linux?

Backup and Restore in computing refers to the process of creating copies (backups) of data and system configurations to protect against data loss, hardware failures, disasters, and other unforeseen events. Backups are essential for ensuring data availability and recovery when needed. Restore is the process of recovering data from backups to its original state.

Here are explanations of two popular backup tools available in Linux:

rsync:
- Description: rsync (remote synchronization) is a versatile and efficient command-line utility for data synchronization and backup. It is widely used for copying, mirroring, and maintaining the consistency of files and directories.
- Features:
  - Incremental Backups: rsync can perform incremental backups, copying only the changed portions of files, which reduces bandwidth and time requirements.
  - Network-Friendly: It supports data transfer over SSH or via the rsync protocol, making it suitable for local and remote backups.
  - Partial File Updates: rsync can update only parts of a file that have changed, ensuring efficient transfers.
  - Excludes and Filters: You can exclude specific files or directories from backups using exclusion patterns.
- Usage Example: To create a local backup of a directory to another location:
```
rsync -av /source_directory /backup_directory
```
  This command copies the contents of source_directory to backup_directory.
Duplicity:
- Description: Duplicity is a powerful open-source backup tool that combines the ease of use of rsync with encryption and remote backup capabilities. It creates encrypted, bandwidth-efficient, and space-efficient backups.
- Features:
  - Encryption: Duplicity provides encryption for backups, ensuring data privacy and security during storage and transmission.
  - Incremental Backups: Like rsync, Duplicity supports incremental backups, saving bandwidth and storage space.
  - Wide Protocol Support: It can back up data to various destinations, including local file systems, remote servers (SSH, SFTP, FTP, etc.), cloud storage (Amazon S3, Google Drive, etc.), and more.
  - Signature Handling: Duplicity uses GnuPG for digital signatures to verify the integrity of backups.
  - Command-Line and GUI: Duplicity can be used from the command line or through graphical user interfaces like Deja Dup.
- Usage Example: To create an encrypted backup of a directory to a remote server using Duplicity:
```
duplicity /source_directory sftp://user@remote_server/backup_directory
```
  This command backs up source_directory to a remote server over SFTP with encryption.
SCP
- SCP (Secure Copy Protocol) is another useful command-line tool in Linux for securely copying files and directories between hosts over a secure encrypted SSH (Secure Shell) connection.
- Features:
- SCP uses SSH for authentication and data encryption, making it highly secure for transferring sensitive data. Like rsync, it provides secure communication.
- SCP has a straightforward syntax, making it easy to use for simple file transfers. It doesn't require complex options or configurations.
- Unlike rsync, SCP doesn't have built-in mechanisms for efficient synchronization or incremental backups. Every transfer is essentially a copy of the entire file.
- SCP is suitable for one-time or occasional file transfers, especially when data security is a priority.
- Example
```
scp /path/to/local/file user@remote_server:/path/to/remote/destination/
```

7. How can you maintain the security in Linux? Write down the security check list in Linux.

Maintaining security in a Linux system is essential to protect against various threats and vulnerabilities. Here's a security checklist for Linux:

Keep the System Updated:
- Regularly update the Linux kernel, system libraries, and software packages to patch known vulnerabilities.
User Authentication:
- Use strong passwords or passphrase-based authentication.
- Implement two-factor authentication (2FA) for critical accounts.
- Disable or lock inactive user accounts.
Firewall Configuration:
- Configure a firewall (e.g., iptables or firewalld) to control incoming and outgoing network traffic.
- Limit open ports to only those necessary for services.
File Permissions:
- Review and set appropriate file permissions using chmod and chown to restrict unauthorized access.
User Privileges:
- Avoid granting unnecessary superuser (root) privileges to users.
- Use the sudo command for privileged operations to limit root access.
Audit Logging:
- Enable and configure audit logging (auditd) to monitor system activities and detect security incidents.
Secure SSH Access:
- Disable SSH root login.
- Use SSH keys for authentication.
- Limit SSH access to specific IP addresses or networks.
Software Security:
- Remove unnecessary or unused software and services.
- Configure software securely, such as web servers (e.g., Apache, Nginx) and databases (e.g., MySQL, PostgreSQL).
Regular Backups:
- Implement regular data backups and test restoration procedures.
- Store backups securely, preferably offsite.
Encryption:
- Encrypt sensitive data at rest using tools like LUKS (Linux Unified Key Setup) for disk encryption.
- Use SSL/TLS encryption for network services.
Security Updates:
- Subscribe to security mailing lists to receive notifications of critical security updates.
- Apply security updates promptly.
Intrusion Detection:
- Install intrusion detection systems (IDS) or intrusion prevention systems (IPS) to detect and respond to suspicious activities.
Security Policies:
- Develop and enforce security policies that specify user responsibilities, password policies, and acceptable use guidelines.
Malware Protection:
- Use antivirus software and perform regular scans, especially for file servers.
Physical Security:
- Secure physical access to servers and data centers.
- Use hardware security modules (HSMs) for cryptographic key protection.
Network Security:
- Segment the network to limit the spread of attacks.
- Monitor network traffic for anomalies using tools like Wireshark or intrusion detection systems.
Incident Response Plan:
- Develop an incident response plan to address security breaches and data breaches promptly.
Logging and Monitoring:
- Set up centralized logging to monitor system and security events.
- Implement a Security Information and Event Management (SIEM) system for log analysis.
Secure Shell (SSH) Hardening:
- Disable password-based SSH authentication.
- Use strong SSH key pairs and limit access to authorized users.
Regular Security Audits:
- Conduct regular security audits and vulnerability assessments of the system and applications.
User Education:
- Educate users and staff about security best practices, social engineering threats, and phishing awareness.
Third-Party Software:
- Be cautious when installing third-party software or repositories; only use trusted sources.
Kernel Hardening:
- Implement kernel hardening techniques, such as kernel module signing and loading restrictions.
Container Security:
- Secure container deployments (e.g., Docker) with proper image scanning and runtime security controls.
Cloud Security (if applicable):
- Implement cloud security best practices when using cloud services like AWS, Azure, or GCP.
Documentation:
- Maintain up-to-date documentation of security configurations and procedures.

8.Write a program to check whether a given number is prime or not using shell scripts.

#!/bin/bash

# Function to check if a number is prime
is_prime() {
  local num=$1
  if [ $num -le 1 ]; then
    echo "Not Prime"
    return
  fi
  for ((i = 2; i * i <= num; i++)); do
    if [ $((num % i)) -eq 0 ]; then
      echo "Not Prime"
      return
    fi
  done
  echo "Prime"
}

# Read input from the user
echo "Enter a number:"
read number

# Call the is_prime function and display the result
result=$(is_prime $number)
echo "Result: $result"

Save this script to a file, e.g., check_prime.sh, and make it executable using the following command:

chmod +x check_prime.sh

9.What are the improvements offered by BASH shell. Write a shell script program to find the given number is palindrome

Bash (Bourne-Again Shell) is a popular and powerful Unix shell that offers several improvements and features over its predecessor, the original Bourne Shell (sh). Some of the key improvements and features of Bash include:

Command History: Bash keeps a command history, allowing you to easily recall and reuse previous commands using the Up/Down arrow keys or by typing history.
Tab Completion: Bash provides tab completion for commands, file paths, and variables, making it easier and faster to navigate and type commands.
Aliases: You can create command aliases using the alias command, simplifying complex or frequently used commands.
Functions: Bash allows you to define and use functions within scripts and the interactive shell, enhancing code modularity and reusability.
Job Control: You can manage and control background and foreground jobs using commands like bg, fg, jobs, and &.
Conditional Statements: Bash supports conditional statements like if, elif, and else, enabling the creation of complex scripts with logic.
Loops: You can use for, while, and until loops to automate repetitive tasks in scripts.
Arrays: Bash supports one-dimensional arrays, allowing you to store and manipulate data more effectively.
Command Substitution: You can use backticks (`) or $(command) to substitute the output of a command into another command or variable.
Arithmetic Operations: Bash can perform arithmetic operations using the $((expression)) syntax.
Input/Output Redirection: Bash allows you to redirect input and output streams using <, >, >>, and pipes (|) to process data efficiently.
Process Control: You can manage processes, send signals, and control process execution using built-in commands.

#!/bin/bash

# Function to check if a number is a palindrome
is_palindrome() {
  local num="$1"
  local reversed=""
  local original="$num"

  while [ "$num" -gt 0 ]; do
    digit=$((num % 10))
    reversed="${reversed}${digit}"
    num=$((num / 10))
  done

  if [ "$original" -eq "$reversed" ]; then
    echo "Palindrome"
  else
    echo "Not a Palindrome"
  fi
}

# Read input from the user
echo "Enter a number:"
read number

# Call the is_palindrome function and display the result
result=$(is_palindrome "$number")
echo "Result: $result"

Save this script to a file, e.g., check_palindrome.sh, and make it executable:

chmod +x check_palindrome.sh

10. How can you schedule jobs in Linux? Explain with an example.

In Linux, you can schedule jobs using the cron system. cron is a time-based job scheduler that allows you to automate tasks and execute them at specified intervals or times. The cron daemon reads configuration files called "crontabs" and runs the scheduled jobs accordingly.

Here's how you can schedule a job using cron:

Edit the User's Crontab:

You can schedule jobs for a specific user by editing their crontab using the crontab command. Each user can have their own crontab.

To edit the crontab for the current user, run:
```
crontab -e
```
Specify the Schedule:

The syntax for specifying the schedule in a crontab is as follows:
```
* * * * * command_to_execute
```
- The five asterisks represent the schedule's timing parameters (minute, hour, day of the month, month, and day of the week).
- * means "every," so * in a field matches all possible values.
- You can specify a specific value or a range of values using numbers or */X to run the command every X units of time.
Write the Command:

After specifying the schedule, add the command you want to run.

For example, to schedule a job that runs a script named my_script.sh every day at 2:30 PM, the crontab entry would be:
```
30 14 * * * /path/to/my_script.sh
```
- 30 is the minute (30 minutes past the hour).
- 14 is the hour (2 PM in 24-hour format).
- * * * * * means every day of the month, every month, and every day of the week.
Save and Exit:

After adding your scheduled job, save and exit the crontab editor.

In the Nano editor, you can typically press Ctrl + O to save the file and Ctrl + X to exit.
View the Crontab:

To list the user's current crontab entries, use:
```
crontab -l
```

Here's an example of scheduling a backup job every day at midnight:

# Edit the crontab for the user
crontab -e

# Add the following line to the crontab file
# This will run the backup_script.sh every day at midnight
0 0 * * * /path/to/backup_script.sh

# Save and exit the crontab editor

In this example, backup_script.sh will be executed daily at midnight (00:00).

11. How do you restore files from your backup data? Explain with an example.

Restoring files from backup data in Linux typically involves copying the files or directories from the backup location back to their original location. The exact procedure can vary depending on how you created and manage your backups, so here is a general example using the cp command.

Assuming you have a backup of your files in a separate directory, let's say /backup, and you want to restore a file named important_file.txt to its original location in your home directory:

# Navigate to your home directory (if you're not already there)
cd ~

# Use the cp command to restore the file from the backup
cp /backup/important_file.txt .

# The dot (.) at the end specifies the current directory as the destination

This command will copy important_file.txt from the /backup directory to your current directory (your home directory).

Here's another example where you restore an entire directory, let's call it my_documents, from the backup:

# Navigate to your home directory (if you're not already there)
cd ~

# Use the cp command with the -r (recursive) option to restore the directory
cp -r /backup/my_documents .

# The dot (.) at the end specifies the current directory as the destination

In this example, the -r option is used to copy the directory and its contents recursively. you can also use scp or rsync command if your backup server and main server are different.

12. Differentiate between Full and Incremental Backup. What is disk mirroring? Explain the process of creating backup with tools you know.

Aspect	Full Backup	Incremental Backup
Definition	A full backup involves copying all data. It creates a complete snapshot of the data at a specific point in time.	An incremental backup copies only the data that has changed or is new since the last backup.
Backup Size	Larger backup size since it includes all data, even if some data hasn't changed.	Smaller backup size as it only includes changed or new data since the last backup
Time and Resource Consumption	Longer backup time and higher resource consumption due to copying all data.	Faster backup and lower resource usage as it only processes changed data.
Restoration Complexity	Easier to restore since all data is in one place and doesn't depend on previous backups.	More complex to restore as it requires the full backup plus all subsequent incremental backups up to the desired restore point.

Space Efficiency	Less space-efficient as it duplicates data that hasn't changed since the last backup.	More space-efficient as it doesn't duplicate unchanged data.
Backup Frequency	Typically less frequent due to the larger size and resource consumption.	Can be more frequent as it only captures changes since the last backup.
Initial Backup Time	Longer time required for the first backup.	Faster initial backup since it's a subset of the full backup.
Dependency on Previous Backups	Not dependent on previous backups for restoration.	Dependent on previous backups; restoring any incremental backup requires the full backup plus all previous increments.
Risk of Data Loss	Lower risk since all data is in one place.	Higher risk if any previous incremental backup is lost or corrupted.

Disk Mirroring: Disk mirroring, also known as RAID 1 (Redundant Array of Independent Disks 1), is a data storage technique that involves duplicating data from one disk (the source or primary disk) to another disk (the mirror or secondary disk) in real-time. The purpose of disk mirroring is to provide data redundancy and fault tolerance.

In disk mirroring:

Data is written simultaneously to both the source and mirror disks.
If one disk fails, the system can continue to operate using the data from the surviving disk.
Disk mirroring offers high data availability and minimizes downtime in case of a disk failure.
It is a straightforward and effective method for ensuring data integrity and reliability.

Creating Backups with Tools: There are various tools available in Linux for creating backups, including rsync, tar, and dedicated backup software like Bacula or Duplicity. Here, we'll provide a general overview of creating backups using the rsync and tar commands:

Using rsync: rsync is a powerful tool for synchronizing files and directories between local and remote systems. It's commonly used for creating backups because it efficiently copies only changed or new files.

Here's a basic example of using rsync to create a backup of a directory:

rsync -av /source_directory /backup_destination

-a: Archive mode, which preserves permissions, ownership, timestamps, and recursively copies directories.
-v: Verbose mode to display progress.
/source_directory: The directory you want to back up.
/backup_destination: The destination where the backup will be stored.

Using tar: tar (short for "tape archive") is a command-line tool for creating archives and backups. It can compress and store files and directories into a single archive file.

Here's a basic example of using tar to create a backup:

tar -cvzf backup.tar.gz /source_directory

-c: Create a new archive.
-v: Verbose mode to display progress.
-z: Compress the archive using gzip.
-f: Specify the archive file name.
backup.tar.gz: The name of the backup archive.
/source_directory: The directory you want to back up.

13. Explain the file permissions in detail.

File permissions in Linux define how files and directories can be accessed, modified, and executed. They play a crucial role in system security by regulating who can perform various actions on files. File permissions are represented by a series of letters and symbols, such as "rwxr-xr--," which convey specific information about access rights. These permissions are primarily associated with three entities:

User (Owner): The user who owns the file or directory. The owner has the most control over the file, including the ability to change permissions and delete it.
Group: A group to which the file or directory belongs. Multiple users can be members of a group, and permissions can be applied to all members collectively.
Others (World): Everyone else who is not the owner or a member of the group.

File permissions are divided into three categories:

Read (r): Allows the entity to read the content of the file or list the contents of a directory.
Write (w): Allows the entity to modify or delete the file, as well as create, delete, or rename files within a directory.
Execute (x): For files, it allows the entity to execute the file as a program or script. For directories, it permits the entity to access the directory and its contents.

Now, let's explore how file permissions are represented and how to set them:

Representation: File permissions are represented as a 9-character string, often displayed as three groups of three characters each. Each group represents the permissions for the owner, group, and others, respectively. The characters in each group are:

The first character indicates the file type. It can be a regular file ("-") or a directory ("d").
The next three characters represent the owner's permissions (read, write, and execute).
The following three characters represent the group's permissions.
The last three characters represent permissions for others.

Symbolic Representation:

To set permissions, you can use symbolic representation. For example:
- chmod u+x file.txt: Adds execute permission for the owner of file.txt.
- chmod go-rw file.txt: Removes read and write permissions for the group and others.

Octal Representation:

File permissions can also be represented using octal numbers. Each permission (read, write, and execute) is assigned a numeric value: read (4), write (2), execute (1). You add these values to set permissions.
- For example, to set read and write permissions for the owner and only read permission for others, you would use chmod 644 file.txt.

Examples of File Permissions:

rw-r--r--: A file where the owner has read and write permissions, while the group and others have only read permissions.
drwxr-xr-x: A directory where the owner can read, write, and access it, while the group and others can only read and access it.

1. What do you mean by Shell Script? Write a shell script program to find factorial of a given number.​

2. What is crontab and explain its functionality and explain the format of crontab? What do you understand by CLI?​

3.For what we need backing-up and restoring features in operating system? Explain backing up strategies.​

4. How can you make secure files in Linux? Explain.​

5.Write a shell script to find the largest among the four numbers.​

6. What is Backup and Restore? Explain any two backup tools available in Linux?​

7. How can you maintain the security in Linux? Write down the security check list in Linux.​

8.Write a program to check whether a given number is prime or not using shell scripts.​

9.What are the improvements offered by BASH shell. Write a shell script program to find the given number is palindrome​

10. How can you schedule jobs in Linux? Explain with an example.​

11. How do you restore files from your backup data? Explain with an example.​

12. Differentiate between Full and Incremental Backup. What is disk mirroring? Explain the process of creating backup with tools you know.​

13. Explain the file permissions in detail.​