Bash history что за файл

6

Torvalds Tuesday: Bash History

For today’s post on Linux artifacts, I’m going to zero in on bash history. I’ll just begin by saying if you spend a lot of time analyzing Windows hosts, bash history will seem like a blessing. Only for a moment, and then it’s gone when you realize the downfall to bash history. That being said, bash history is an important artifact that deserves is own focus as it can help detail so much about our attackers.

For the purposes of this post, I’m doing analysis on a Debian 8.5 VM I have. Your miles may vary as I, for one example, rely on package manager-specific logs. This does not exclude other distributions, it just means the artifacts may be different. Other examples should also work well and may not depend on the type of Linux distribution.

Bash history, or the GNU History library, keeps track of commands issued by the user line-by-line. History has made it relatively simply to repeat commands, change arguments for a previous command, or recall previous commands to quick fix errors (I’m paraphrasing much from the man page of history).

Bash history is read when the shell starts, and is written at exit — generally. Despite the simplicity of being a history of lines from a shell, it’s behavior can be customized. Bash has quite a few environment variables that can achieve this. A few key variables include:

• HISTCONTROL — A colon-separated list of values controlling how commands are saved on the history list.
• HISTFILE — The name of the file in which command history is saved; again, the default for this value is

There are other options available. I’d highly recommend checking out man bash on a test system to learn how variables can manipulate history files. If you find yourself performing live analysis on a system, I recommend dumping environment variables to see if the history file is being manipulated at all.

Do You Have the Time?

As I’ve alluded to, bash history contains one downfall. Timestamps are not included in bash history by default. However, this is easily solved! You can set a time format using the environment variable HOSTTIMEFORMAT and will find timestamps appended. See the screenshot below:

Now, before we throw a party that bash includes timestamps, do you notice any issues with the timestamps above? That’s right, every command prior to the most recent session gets marked with the same timestamp. The takeaway here is that enabling timestamps on bash history is not much of a retrospective step; more of a proactive step.

I’d highly recommend checking out Hal Pomeranz’s post on bash history. Hal did an awesome job analyzing bash history artifacts, when history files may not be written, and possible anti-forensic techniques. DFIR analysts who are analyzing Linux systems should be aware of these methods! Thanks Hal for sharing that awesome information with us!

Accessing Bash History

On a live system, the Bash history can be displayed by simply typing history . In return, you’ll get a list of previous commands preceded by numerical order. As you can imagine, if your bash history is untouched and the max file size allows it, you may go all the way back to when the user account was first used.

If you’re performing remote or dead forensics, bash history files are typically located under each user profile. They are aptly named .bash_history , and contain an ASCII list of commands issued by that particular user. Again, the file name is dependent on no alternate file designated by the HISTFILE variable (and of course history actually being record).

Pinpointing Bash History

As discussed above, unfortunately default bash history does not include timestamps by default. They can be enabled, but as the example above showed, dates previous to the current session will stamped with a single timestamp relative to the last session. However, that does not mean we are entirely in the dark about when things happened!

The goal with most investigations is to answer the question of what happened when. By coupling bash history with some other support files, we can actually begin to define time periods to an artifact with no time keeping. Here are a few examples:

Context with additional logs

Another neat little artifact on systems is the file /var/log/apt/history.log . This file is a record — a history of its own — of package installations. Here’s a quick snippet from one of my Debian VMs:

In the example above, you can clearly see I installed zlib1g-dev and libssl-dev between 18:07:00 and 18:07:27 on September 16, 2016. Let me pull the same contents from my .bash_history file:

Now, we’ve got some additional context. Based on the timestamps we can assign — thanks to the apt history log — it looks as though the user (me in this case) was attempting to compile and install something, and was downloading dependencies as the script ran into errors. I can see that potentially there’s a file called bootstrap.sh related to this install.

Now, let’s think about if this was an attacker. A few questions come to mind:

• What did the attacker install?
• I should search the system for the file boostrap.sh , and see exactly what that file does.
• Notice that the attacker ran make and then sudo make install . If they are successfully executing sudo commands, then I can assume they have the password for the account (which is part of the sudoers group) and/or have enabled sudo privileges. This naturally will lead me to also examine the root account.
• Do the installed dependencies tell me anything about the specific program? In this example, I believe I was installing AFFlib .

Context with file timestamps

Another method to attach timestamps to bash history is to find an action that affected a system timestamp, and look at that file’s attributes. Consider the following example:

Using the touch command, I created an empty file named .secret_file . This file is hidden from a normal user, but the attacker may know it was there. Now, let’s look at at the metadata for this file:

Notice that we’ve got timestamps for the file around today, 2016–12–27, at approximately 20:02 CST. As the file is still zero bytes in size and all three timestamps are identical, I can make a safe bet that this entry was around this time. Let’s look at .bash_history for the next few lines:

Now, let’s look at the metadata for the file .secret_file2 :

Awesome! Using these two artifacts, I can paint an approximate 5-minute window that my attacker was on the host. It also looks like there was some SCP activity to a known bad IP address. If I wanted to get my network forensic team involved, I could throw them this timeframe and ask for related traffic. All that from an artifact with no timestamps!

Context with network traffic

In the previous example, I discussed handing off indicators to the network forensics team to assist with analysis. In other cases, we can start with network data to timestamp our bash history. Consider the syntax from the following commands:

• wget [OPTION]… [URL]…
• curl [options…] <url>

These commands are typically used to download files from the Internet. If we’ve got recorded evidence of this activity, we could use our network traffic to identify that time and pinpoint our history.

Context with other users

When analyzing bash history files, don’t forget that files are unique to users. If you see an attacker change to a root account or another user, you need to pull those histories as well. Unfortunately, as mentioned, we can’t simply overlay the histories and watch the attacker walk through the host. Instead, we can correlate artifacts and use the timestamps we can identify to determine account activity.

Context with other hosts

In this last example, consider an attacker who has high enough privileges that they can move laterally around multiple systems. We can utilize the authentication logs from the remote system to pinpoint timestamps on our local infected host. While yes, this is basically log correlation, we are unfortunately having to utilize another host to perform it.

Also keep in mind that if we see lateral movement, our infected host list should be growing quickly.

Wrap-Up

If anyone finds themselves performing Linux forensics, I hope that bash history is still intact and is available for examination. Remember that the lack of timestamps doesn’t have to mean a useless artifact, it just means we have to do a bit more digging and correlation.

A Complete Guide to Linux Bash History

Developers, sysadmins, and DevOps engineers spend a lot of time at the Linux command line. And, invariably, we make tpyos typos. Other times, we just need to run the same command again or determine what commands were previously executed on a system. In all of those cases, knowing how to work with bash history helps.

In this article, we’ll take a closer look at what bash history is, how bit works, and how you can use it to become a more efficient when you’re working at the Linux command line. You can follow along with the commands in this article using almost any modern *nix operating system with bash.

What is bash history?

The term bash history refers to the commands, files, and shortcuts that allow you to view, modify, and delete bash commands that have been run on a system.

Bash has two bulitin commands for working with bash history:

• history — Allows you to list commands and modify your bash history.
• fc — Allows you to list, edit, and execute commands from your bash history.

Because the term "bash history" often implies the history command, we’ll focus on the mechanics of the history command instead of fc for most of this article.

In addition to these two bulitin commands, there are a variety of files (like

/.bash_history ), expansions (like !! ), and keyboard shortcuts (like the ↑ and ↓ keys) that help you work with bash history.

In the sections below, we’ll explore how these aspects of bash history work.

How does bash history work?

By default, history stores commands in RAM until you log out of the terminal. Once you log out, commands are written to disk in the

/.bash_history file. The history buffer is limited to 1,000 command entries and the history file is limited to 2,000 entries.

You can modify the default behavior of the history command by setting environment variables, which we’ll review in more detail shortly.

Working with Bash history: The basics

The easiest way to get started working with bash is to run the history command with no options. You should see output similar to this:

The numbers next to the commands indicate the order they were entered into the history (the oldest command being 1). You can also use the ↑ and ↓ keys on your keyboard to scroll through your bash history.

We can limit the output to the last N commands with the command history N . For example, history 2 will return the 2 most recent commands.

You can pipe history into grep or less to make it easier to filter the output.

You can delete a specific entry with the history -d N where N is the number of the command or a range of numbers. For example, history -d 2-4 deletes commands 2, 3, and 4 from our history.

To clear the history buffer (i.e., the commands saved in RAM for the current terminal session) use the command history -c .

The bash history saved to disk is in the $HISTFILE which is

/.bash_history by default. You can clear that file with a command such as:

Configuring bash history settings with .bashrc

In some cases, you may want to modify how bash history works on your Linux system. Adding Linux environment variables to your

/.bashrc file can help you do just that. Here are some common use cases for customizing bash history using

As we go, remember that changes to a user’s

/.bashrc file take into effect after logging out and logging back into your shell. Alternativelly, you may run .

/.bashrc or source

/.bashrc to reload bash settings.

Exclude commands from bash history

You may want to exclude commands from bash history to avoid noise in the output or for security reasons. On many Linux distros, you can prevent a command from being included in bash history by adding a space before you execute the command.

However, that may not hold true on all distros. Whether or not leading spaces are ignored depends on the $HISTCONTROL environment variable. If $HISTCONTROL is set to ignoreboth or ignorespace , commands with a leading space are not saved to history.

To exclude commands from your bash history with

/.bashrc , you can use the $HISTIGNORE environment variable. $HISTIGNORE allows you to define a colon separated list of command patterns that will not be saved to your bash history. For example, to ignore any sudo commands or any commands where echo is followed by a w , add this to your

Immediately persist commands to .bash_history

It’s common for users to have multiple terminals open for the same user account, and this is where things can get tricky. By default, the history command will only show commands from the current terminal session and the commands that are saved to the

/.bash_history file are the commands from the last session to log out.

To immediately persist commands to your

/.bash_history file, you can add this to

Add date and timestamps to bash history output

Often, knowing when you ran a command is an important part of knowing which command you need now. Adding timestamps to your bash history output can help make this easier.

To include timestamps with your bash history, add this to your

%F adds the date in YYYY-MM-DD format and %T adds a HH:MM:SS timestamp. Here is an example of what history command output looks like with this bash environment variable set.

Note that the space after the %F and %T is useful for formatting the output. Without the spacing, the date, timestamp, and command would all run together.

Modify bash history buffer and file size

If the default values of 1,000 command entries in the history buffer and 2,000 entries in the history file isn’t what you want, you can change the $HISTSIZE (buffer) and $HISTFILESIZE (file) environment variables.

For example, to set both to 11,000 entries, modify the default values to read:

Useful bash history keyboard shortcuts

In addition to the history command, there are several keyboard shortcuts that make working with bash history easy. Here are some of the most useful:

Bash history expansion

If you’ve ever run sudo !! , you’ve already used a bash history expansion command. However, there are plenty of other ways to use expansion commands to work with your bash history. Here is a list of some of the most useful bash history expansions:

Here’s a simple example to demonstrate the logic:

Note that in the example we added a space before our expansion commands so they aren’t included in our bash history.

Bash history designators

All three of the previous expansion commands are examples of designators. And there are several more powerful designators you can use to work with your bash history.

!<command> will execute the most recent <command> in your bash history. For example, suppose we have these commands in our history output:

!curl will run curl -Lo cherry.html cherryservers.com , !ls will run ls -la , etc.

You can also use ^ designators to substitute parts of the most recent command in your bash history with different content. The general format is:

For example, if the previous command in your history was:

And you wanted to change /path/wrongplace to /path/rightplace instead of typing the entire command again, you could run:

And the output would be similar to:

Use designators to get arguments from a command

You can use a colon : followed by a specific designator to add arguments from the most recent command in your history to a subsequent command. The table below details some of the common designators:

Below is an example to visualize the concept:

Bash history modifiers

Bash history modifiers complement designators by changing the content or execution of the command. You specify modifiers after a command with a colon and a letter (e.g., :h )

Here are some common bash history modifiers and what they do.

For example, suppose we wanted to list all the .log files in a directory with ls /directory/*.log but instead we ran the command ls /directory/*.txt . We could use the command !:s/txt/log to correct the mistake. End-to-end, it would look similar to this:

Conclusion

With knowledge of bash history, you can work more efficiently at a Linux terminal. The information we covered here should help you handle most of the common bash history use cases you’ll encounter. For a deeper dive on bash history, we recommend reading the GNU manpage for the bulitin bash history commands and testing different designators and customizations in your own test environment.

For more Linux administration content like this, subscribe to the Cherry Servers blog!

Mantas Levinas

Helping engineers learn �� about new technologies and ingenious IT automation use cases to build better systems ��

Join Cherry Servers Community

Get monthly practical guides about building more secure, efficient and easier to scale systems on an open cloud ecosystem.

Как использовать историю команд в Bash на Linux VPS

В серверной среде работа с командной строкой занимает много времени. Часто используется оболочка bash – командная оболочка по умолчанию большинства дистрибутивов.

Вероятно, во время терминальной сессии общие команды будут повторяться часто, а вариации данных команд – еще чаще. Конечно, сначала набирать каждую команду вручную очень полезно, так как это – лишняя возможность попрактиковаться, но в какой-то момент это начинает надоедать и раздражать.

К счастью, bash-оболочка имеет некоторые довольно хорошо разработанные функции истории. Умение продуктивно использовать и управлять историей в bash позволяет тратить меньше времени на ввод команд, и тем самым увеличивает объем выполненной работы. Как известно, среди разработчиков популярен так называемый принцип DRY (Don’t Repeat Yourself). Продуктивное использование истории в bash помогает работать с информацией согласно данному принципу.

Это руководство демонстрирует все функции на VPS с Ubuntu 12.04, но почти все современные дистрибутивы Linux будут работать подобным образом.

Настройки истории в bash

Прежде чем использовать историю, нужно отредактировать некоторые настройки bash, чтобы сделать ее более применимой.

Bash позволяет редактировать количество предыдущих команд, которые нужно сохранить в истории. Для этого в bash есть две отдельные опции: параметр «HISTFILESIZE» задает количество команд, хранящихся в файле истории, а «HISTSIZE» указывает количество команд, которое сохраняется в памяти для текущей сессии.

Это означает, что в памяти можно установить разумные пределы размера истории для текущего сеанса, а также хранить более объемную историю на диске для дальнейшего использования.

По умолчанию bash устанавливает очень умеренные значения этих параметров, поэтому их необходимо расширить, чтобы иметь возможность использовать более полную историю. Некоторые дистрибутивы уже увеличили значения параметров истории по умолчанию.

Чтобы изменить данные опции, откройте файл «

/.bashrc» с помощью редактора:

Найдите опции «HISTSIZE» и «HISTFILESIZE». Если значения для них установлены, измените их. Если таких параметров в данном файле нет, внесите их. Данное руководство может обойтись 10000 строк для диска и 5000 строк, сохраненных в памяти. Это достаточно скромные значения для большинства систем, но даже их придется понизить, если они влияют на производительность:

По умолчанию bash пишет историю в конце каждой сессии, переписывая и обновляя уже существующий файл. Это значит, что при работе в нескольких bash-сессиях будет сохранена только история последней завершенной сессии.

Это можно обойти, установив параметр «histappend», который будет добавлять историю, а не перезаписывать её. Возможно, он уже установлен​​; в противном случае его можно активировать, добавив следующую строку:

shopt -s histappend

Чтобы bash вносил команды в историю сразу, не дожидаясь завершения сессии (чтобы команды одного терминала сразу же были доступны в другом), можно установить или добавить команду «history –a» для опции «PROMPT_COMMAND», которая содержит команды, которые выполняются перед каждой новой командной строкой.

Но для правильной работы такой команды нужна уловка. В файл истории нужно сразу добавить «history –a», затем очистить текущую историю данной сессии с помощью «history –c», после этого прочесть отредактированный файл истории и вернуться в историю данной сессии с помощью «history –r».

Это выглядит примерно так:

export PROMPT_COMMAND=»history -a; history -c; history -r; $PROMPT_COMMAND»

Завершив эту операцию, сохраните изменения и закройте файл.

Чтобы активировать изменения, выйдите из системы и войдите снова, либо используйте команду source на данный файл, набрав:

Просмотр предыдущей истории в Bash

Для просмотра истории в Bash используется команда «history». Она выводит предыдущие команды, по команде на строку. В большинстве случаев она должна вывести количество строк, установленное значением «HISTSIZE». На данный момент команд не так много:

history
. . .
43 man bash
44 man fc
45 man bash
46 fc -l -10
47 history
48 ls -a
49 vim .bash_history
50 history
51 man history
52 history 10
53 history

Также она выводит порядковый номер команды. Каждая команда связана с номером для удобства использования.

Вывод можно сократить, указав количество команд после «history». Например, если нужно вывести только последние 5 введенных команд, можем набрать:

history 5
50 history
51 man history
52 history 10
53 history
54 history 5

Чтобы найти в истории все команды, которые содержат определенную строку, можно просто использовать grep после символа вертикальной черты. Например, чтобы найти строки, содержащие «cd», наберите:

history | grep cd
33 cd Pictures/
37 cd ..
39 cd Desktop/
61 cd /usr/bin/
68 cd
83 cd /etc/
86 cd resolvconf/
90 cd resolv.conf.d/

Запуск команд из истории в Bash

Научиться выводить команды, конечно, полезно, но, кроме использования порядкового номера команд, это почти ничего не дает. Для вызова любой предыдущей команды нужно использовать специальный синтаксис.

Вызвать любую из предыдущих команд можно, введя ее номер и поставив перед ним восклицательный знак «!». Опираясь на приведенный выше пример истории, можно быстро вывести оперативную страницу руководства, просто введя:

Это немедленно вызовет и выполнит команду в истории под номером 51.

Можно также выполнять команды относительно текущей позиции. Это делается с помощью синтаксиса «!-n», где «n» нужно заменять номером команды, которую нужно выполнить.

К примеру, если нужно вывести и выполнить предпоследнюю набранную команду, то можно набрать «!-2». Итак, если было выведено содержимое длинного пути к каталогу, а затем введена команда echo, и теперь нужно снова вывести путь, то сессия может выглядеть следующим образом:

ls /usr/share/doc/manpages
echo hello
!-2 # lists the contents again

Чтобы повторно выполнить последнюю команду, вместо использования «!-1» в bash можно использовать «горячую» команду «!!», что выполняет:

Многие используют это в случае, если они набрали команду, требующую привилегий sudo. При наборе «sudo !!» команда будет перевыполнена с привилегиями sudo. Такая сессия выглядит примерно так:

touch /etc/hello
touch: cannot touch `/etc/hello’: Permission denied
sudo !!
sudo touch /etc/hello
[sudo] password for demouser:

Данный пример демонстрирует еще одно свойство этого полезного синтаксиса. По сути, это простая замена, потому при необходимости его можно включать в другие команды.

Прокрутка истории в Bash

Прокрутить историю в Bash, выводя каждую последующую команду в командной строке для редактирования, можно несколькими способами.

Наиболее распространенным способом является нажатие клавиши со стрелкой вверх в командной строке.

Каждое дополнительное нажатие этой клавиши будет возвращать на шаг назад в истории командной строки. Чтобы изменить направление, используйте клавишу со стрелкой вниз, которая прокручивает историю вплоть до последней командной строки.

Вместо клавиш со стрелками можно использовать сочетания клавиш: «CTRL-p» для прокрутки истории назад, и «CTRL-n» для прокрутки вперед.

Чтобы вернуться к текущей командной строке, можно использовать «Meta->». В большинстве случаев «meta» и символ «>» заменяют комбинацию «ALT-Shift-.». Это очень полезно в случае, если текущая командная строка находится достаточно далеко.

Чтобы переместиться к первой строке истории, используйте обратный манёвр, «Meta-<». Обычно это сочетание замещает «ALT-Shift-,».

В качестве подведения итогов ниже приведен список наиболее важных клавиш перемещения по истории:

• Клавиша со стрелкой вверх: прокрутка истории назад;
• CTRL–p: прокрутка истории назад;
• Клавиша со стрелкой вниз: прокрутка истории вперед;
• CTRL–n: прокрутка истории вперед;
• ALT–Shift-.: перемещение в конец истории (к последней введенной команде);
• ALT–Shift-,: перемещение в начало истории (к первой введенной команде).

Поиск по истории в Bash

Хотя использование комбинации «history | grep» – самый простой способ выполнения некоторых процедур, его работа во многих ситуациях далеко не идеальна.
Bash имеет функции поиска по истории. К примеру, часто используется поиск по истории в обратном направлении (сначала выводятся самые «свежие» результаты) с помощью сочетания клавиш «Ctrl-r».

Например, можно ввести «Ctrl-r» и набрать часть предыдущей команды. Необходимо набрать только часть команды. Если же введенное значение совпало с ненужной командой, можно снова нажать «Ctrl-r», чтобы вывести следующий результат.

Если нужная команда была случайно пропущена, можно изменить направление поиска при помощи комбинации «CTRL-s». Это также полезно при перемещении по истории, описанном в предыдущей главе, для поиска вперед.

Примечание: во многих терминалах, комбинация «CTRL-s» блокирует сессию терминала. То есть, при попытке использовать ее для поиска она будет «замораживать» терминал. Чтобы разблокировать сессию, просто наберите «Ctrl-q».

Эти функции приостановки и возобновления сессии в большинстве современных терминалов не нужны, потому их можно отключить, набрав:

Теперь нужно внести это в файл «

/.bashrc», чтобы обеспечить постоянное выполнение команды.

Теперь эта комбинация поиска будет работать верно.

Поиск по введенной части команды

Распространенный способ поиска – ввести часть команды, выяснить, была ли она выполнена ранее, и затем найти ее в истории.

Как правильно выполнить поиск, используя уже внесенные в командную строку данные? Переместите курсор в начало строки при помощи «CTRL-a», затем вызовите обратный просмотр истории «CTRL-r», вставьте текущую строку в поиск с помощью «CTRL-y», и снова используйте «CTRL-r» для обратного поиска.

К примеру, необходимо обновить кэш пакета в Ubuntu. Эта команда уже была выполнена, но чтобы проверить, так ли это, можно набрать sudo:

На данном этапе видно, что эта команда точно уже выполнялась недавно. Теперь нажмите:

Это переведет курсор в начало строки.

Это вызовет обратный последовательный поиск по истории. Это действие имеет побочный эффект – оно копирует все содержимое командной строки, что находится после текущего положения курсора, и вставляет его в буфер обмена.

Это вставляет только что скопированные из командной строки части команды в поиск.

Теперь нужно снова запустить обратный поиск по истории, чтобы найти команды, содержащие указанную часть.

Сначала эта процедура кажется довольно запутанной, но к ней просто нужно привыкнуть. Она чрезвычайно полезна в те моменты, когда половина сложных команд была введена, и теперь для завершения работы нужна история.

Кроме того, все эти действия можно объединить в одно:

Продвинутое использование истории в bash

Рассмотрев основные техники использования истории, существующие в bash. Среди них:

• !!: вывести последнюю команду;
• !n: перейти к команде с порядковым номером «n»;
• !-n: перейти к команде, которая была под номером «n» перед выполнением последней команды.

Определители события

Три вышеперечисленных комбинации называются определителями события. По сути, это способ вызова предыдущих команд из истории при помощи определенных критериев.

К примеру, чтобы выполнить последнюю команду «ssh», можно использовать:

Это действие ищет строки, которые начинаются с «ssh». Чтобы найти последовательность, которая находится не в начале команды, можно ввести символ «?» перед и после последовательности. К примеру, чтобы повторить последнюю команду «apt-cache search», нужно набрать:

Также можно использовать вариации вывода последней команды («!!»). Выполнить быстрый поиск и замену, набрав:

Это вызовет последнюю команду (как «!!»), ищет совпадение со значением «original», и заменяет его значением «replacement». Затем команда будет выполнена.

Это очень удобно применять при необходимости исправить орфографические ошибки. К примеру:

cat /etc/hosst
cat: /etc/hosst: No such file or directory
^hosst^hosts^

Определители слов

После определителей события можно добавить символ двоеточия (:), а затем внести определитель слова, чтобы выбрать часть совпавшей команды.

Это работает путем деления команды на «слова» – участки, разделенные пробелами. Это открывает новые возможности взаимодействия с параметрами команд.

Сама команда нумеруется нулем, первый аргумент – 1, и так далее.

К примеру, можно вывести содержимое каталога, а затем изменить его таким образом:

ls /usr/share/doc/manpages
cd . 1

Если данная операция выполняется с последней запущенной командой, то эту комбинацию можно сжать, убрав второй «!» и двоеточие:

Это будет работать тем же образом.

На первый аргумент можно сослаться при помощи символа «^», а на последний аргумент – «$». Эти символы намного полезнее при работе с диапазонами, а не порядковыми номерами. К примеру, извлечь все аргументы из предыдущей команды в новую можно тремя способами:

Символ звездочки «*» применяется для обозначения вывода любых данных, кроме исходной команды. Аналогично, можно использовать номер слова, указав после него *, чтобы обозначить, что все после указанного слова должно быть также включено.

Модификаторы

Последнее, чем можно дополнить поведение вызванной строки истории – это изменение поведения вызова для управления самим текстом. Модификаторы вносятся после дополнительного символа «:» в конце строки.

К примеру, сократить путь к файлу можно при помощи модификатора «h» (что значит «head»), который удаляет путь до последнего символа слеша (/). Запомните: это не будет работать должным образом при необходимости сократить путь к каталогу, который заканчивается символом слеша.

Это часто используется при изменении файла и необходимости перейти в его каталог, чтобы выполнить операции на связанные с ним файлы.

К примеру, можно прочитать информацию об авторских правах пакета:

После этого нужно перейти в каталог. Это можно сделать при помощи команды «cd» на строку параметров, «отрезая» имя файла в конце.

cd . $:h
pwd
/usr/share/doc/manpages

Теперь нужно снова открыть этот файл об авторских правах.

Можно также выполнить обратную процедуру, сокращая путь и используя только имя файла, при помощи модификатора «t» (что значит «tail»). Для примера можно поискать последнюю команду «cat», используя флаг «t», чтобы оставить только имя файла.

Можно также просто оставить полный путь, и команда будет работать должным образом. Но иногда это не так. К примеру, если при работе с файлом, вложенным в несколько подкаталогов текущего каталога, использовать относительный путь, и изменить подкаталог с помощью модификатора «h», то использовать относительный путь к данному файлу больше не получится.

Еще один очень полезный модификатор – «r», удаляющий хвостовой суффикс вида “.xxx”. Это полезно при использовании команды «tar» для распаковки файла и необходимости после этого перейти в каталог. Предполагая, что имя каталога совпадает с именем файла, можно выполнить что-то вроде:

tar xzvf long-project-name.tgz
cd . $:r

Если tarball использует расширение tar.gz вместо tgz, просто введите модификатор дважды:

tar xzvf long-project-name.tar.gz
cd . $:r:r

Похожий модификатор, «е», удаляет все, кроме хвостового расширения.

Если вызываемую команду нужно просто найти, а не выполнить, можно использовать модификатор “p”, чтобы bash снова отобразил команду.

Это полезно, если нужно убедиться в правильности выбранного отрывка истории. Кроме того, этот модификатор поместит выбранную команду в историю на случай если она нуждается в дальнейшем редактировании.

К примеру, команда “find” была ранее запущена на домашний каталог, а теперь ее нужно запустить из этого каталога (/). Проверить, правильно ли выполнена подстановка, можно следующим образом (при условии, что данная команда имеет №119):

-name «file1» # original command
!119:0:p / !119:2*:p
find / -name «file1»

Если же команда была выведена верно, ее можно запустить при помощи:

Есть и более простой способ выполнения подстановки в командах: для этого можно использовать синтаксис s/original/new/

К примеру, описанное выше действие можно выполнить так:

Это заменит первый экземпляр поискового шаблона. Чтобы выполнить подстановку на каждое совпадение, используйте модификаторы “g” и “s”. К примеру, чтобы создать файлы по имени ” file1″, “file2” и “file3” и каталоги “dir1”, “dir2”, “dir3”, нужно использовать:

touch file1 file2 file3
mkdir . *:gs/file/dir/

Итоги

Данное руководство помогает овладеть основными понятиями использования истории. Конечно, некоторые из описанных функций будут полезны в редких случаях, но знать о них и уметь их использовать также необходимо.

В целом, все описанные возможности использования истории могут существенно ускорить работу.

Работа в Linux с историей команд (history)

Как говориться «лень — двигатель прогресса» поэтому я покажу как можно еще работать с командной строкой bash, стандартно с помощью клавиш перемещения курсора можно перемещаться по списку ранее введенных команд. Если мне была нужна определенная команда из ранее введенных — „стрелка вверх“ и до тех пор пока нужная команда не появиться в терминале далее корректировка по надобности и выполнения ее.
Оказываеться есть еще один хороший способ — для просмотра списка ранее введенных команд в bash — имеется команда history. По умолчанию она выводит список команд хранящийся в истории.
$ history
1 sudo route del -net
2 cat /etc/resolv.conf
3 htop
.
50 nslookup
51 ping mail.ru
52 ifconfig
.
200 sudo aptitude full-upgrade
.
300 mc

По умолчанию все пишиться в файл

/.bash_history, а его размер — 500 команд.
Если хотим хранить историю в другом файле, то нужно в .bashrc, задать команду HISTFILE=

/.my_history.
HISTSIZE — определяет число строк, хранящихся в списке истории (в памяти интерпретатора).
HISTFILESIZE — максимальное количество команд хранящихся в файле истории.
Если интересует больше записей, по можно поменять под себя:

$ export HISTSIZE=1000
$ export HISTFILESIZE=1000

При запуске команды history без параметров, выдаеться весь список сохранненных команд, что довольно громоздко, поэтому есть возможность указать
количество выводимых строк (команд):
$ history 20
280 sudo aptitude full-upgrade
281 ps ax | grep conky
282 dig @217.23.122.130 ya.ru mx
.
300 mc
Выдаст 20 последних команд, все команды имеею свой номер, с помощью которого к ней можно обратится.
Если нам надо повторить 282 команду, то просто набираем в терминале:
$ !282
dig @217.23.122.130 ya.ru mx
; <<>> DiG 9.5.0-P2 <<>> @217.23.122.130 ya.ru mx
; (1 server found)
. .
Сначало показываеться команда соответствующая этому номеру, потом ее выполнения.
Cписок наиболее распространенных команд:

• !! — ссылается на предыдущую команду;
• !n — ссылается на команду под номером n;
• !-n — ссылается на команду по номером „текущая минус n“;
• history -c — очистить историю команд, удалив все записи
• history -d n — удалить из истории запись под номером n
• history -a — дописать команды, введенные в текущей сессии bash, в конец файла $HISTFILE

Дополнения:
Так же можно сохранить дату и время для каждой команды в истории, для этого в конец .bashrc дописываем:
$ nano .bashrc

и применяем изменений в .bashrc без перезапуска сеанса/системы делаем командой
$ bash
Получаем :
$ history 3

147 Aug/11 — 11:05:28 sudo aptitude install gspca-source
148 Aug/11 — 11:07:23 cd /lib/modules/2.6.32-22-generic/
149 Aug/11 — 11:11:08 modprobe gspca

Контролируйте Bash History

HISTCONTROL — представляет из себя список опций, разделенных двоеточиями.

Они контролируют каким образом список команд сохраняется в истории.

Пример :

Добавьте в .bashrc:

export HISTCONTROL=»ignoredups»

Это заставит bash игнорировать дупликаты, так же как ls, bg, fg и exit, делая историю чище.

Забытая история bash.

Если вы открыли терминал и печатаете там команды, потом открыли еще один, немного его поиспользовали, то новый терминал не «вспомнит» ни одной команды, напечатанной в первом. Вдобавок, при закрытии первого терминала второй перезапишет все команды в истории, введённые в первом. Вдвойне досадно!

Это происходит потому, что история bash сохраняется только когда вы закрываете терминал, а не после каждой команды. Чтобы исправить такое поведение, добавьте в

shopt -s histappend
PROMPT_COMMAND=`history -a`

Добавьте следующую строку, если переменная $PROMPT_COMMAND уже была задана :

Это заставит bash дополнять историю вместо того, чтобы перезаписывать её: каждый раз, когда показывается приглашение командной строки, последняя команда добавляется в историю.

Увеличиваем Размер Хранимой Истории

Увеличьте HISTSIZE — количество команд, которые необходимо запоминать в списке истории (стандартное значение — 500).

Увеличьте HISTFILESIZE — максимальное количество строк, содержащееся в файле истории (стандартное значение — 500).

Одна Команда — Одна Запись в Истории

Сохранять все строки многострочной команды в одной записи списка истории :

Изменить Имя Файла с Историй Команд

Используйте HISTFILE для изменения имени файла, в котором сохраняется история команд. Стандартное значение