Для проведения исследований работы программ и ОС существует очень много различного инструментария. Виртуальные машины, IDE, умные блокноты, IDA, radare, hex-редакторы, pe-редакторы, и даже одних утилит Sysinternals больше сотни — все это сделано для облегчения многих рутинных операций. Но иногда наступает момент, когда ты понимаешь, что среди всего этого многообразия тебе не хватает небольшой утилитки, которая просто сделает банальную и нехитрую работу. Можно написать скрипты на питоне или Powershell на коленке, но нередко на такие поделки без слез не взглянешь и с коллегами не поделишься.

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

Ошибка проявляется так – если в WPF приложении, в стандартный контрол TextBox воткнуть много строк текста, то вызовы функции GetLineText() начиная с некоторого индекса будут возвращать неправильные строки.


Неправильность заключается в том, что хоть строки будут из установленного текста, но расположенные дальше, фактически GetLineText() будет просто пропускать некоторые строки. Ошибка проявляется при очень большом количестве строк. Так я ее и встретил – попытался отобразить в TextBox’е 25 мегабайт текста. Работа с последними строками выявила неожиданный эффект.

Гугл подсказывает, что ошибка существует с 2011 года и Microsoft не особо торопится что-то исправлять.

Пример

Требований к версии .NET особо нет. Создаем стандартный проект WPF и заполняем файлы так:
MainWindow.xaml

<Window x:Class="wpf_textbox.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:wpf_textbox"
        mc:Ignorable="d"
        Title="WTF, WPF?" Height="350" Width="525">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <RowDefinition Height="20"/>
            <RowDefinition Height="20"/>
        </Grid.RowDefinitions>
        <TextBox Grid.Row="0" Margin="5" Name="txt" AcceptsReturn="True" AcceptsTab="True" />
        <Button Grid.Row="1" Content="Fire 1!" Click="btn_OnClick" />
        <Button Grid.Row="2" Content="Fire 2!" Click="btn2_OnClick" />
    </Grid>
</Window>

MainWindow.cs (пропустив using и namespace)

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private void btn_OnClick(object sender, RoutedEventArgs e)
    {
        var sb = new StringBuilder();
        for (int i = 0; i < 90009; i++)
            sb.AppendLine($"{i}");
        txt.Text = sb.ToString();
    }

    private void btn2_OnClick(object sender, RoutedEventArgs e)
    {
        var sb = new StringBuilder();
        for (var i = 1; i < 7; i++)
            sb.AppendLine("req: " + 150 * i + ", get: " + txt.GetLineText(150 * i).Trim());
        for (var i = 1; i < 7; i++)
            sb.AppendLine("req: " + 15000 * i + ", get: " + txt.GetLineText(15000 * i).Trim());
        txt.Text = sb.ToString();
    }
}

Приложение состоит из TextBox’а и двух кнопок. Нажимаем сначала “Fire 1!” (заполнит TextBox чиселками), затем “Fire 2!” (запросит строки по номерам и выведет).

Ожидаемый результат:

req: 150, get: 150
req: 300, get: 300
req: 450, get: 450
req: 600, get: 600
req: 750, get: 750
req: 900, get: 900
req: 15000, get: 15000
req: 30000, get: 30000
req: 45000, get: 45000
req: 60000, get: 60000
req: 75000, get: 75000
req: 90000, get: 90000

Реальность:



Видно, что для индексов меньше 1000 – все прекрасно, а для больших 15000 – пошли сдвиги. И чем дальше, тем больше.

Исследуем баг

Расчехляем ту часть решарпера, которая отвечает за просмотр исходного кода .NET и специальный класс «Расширитель возможностей и преодолятор ограничений на базе Reflection».


Опытным путем устанавливаем, что в конкретно взятом примере проблема начинается в районе 8510 строки. Если запросить txt.GetLineText(8510), то вернется “8510”. Для 8511 – 8511, а для 8512 – внезапно, 8513.

Смотрим на реализацию GetLineText() у TextBox:


Пропускаем проверки в первых строчках и видим вызов GetStartPositionOfLine(). Похоже, что проблема должна быть в этой функции, поскольку для неправильной строки должна вернуться неправильная позиция начала строки.

Вызываем в своем коде:

var o00 = txt.InvokeMethod("GetStartPositionOfLine", 8510);
var o01 = txt.InvokeMethod("GetStartPositionOfLine", 8511);
var o02 = txt.InvokeMethod("GetStartPositionOfLine", 8512);

И правда – смещение первого объекта (начало 8510'ой строки) указано как 49950 символов, для второго объекта – 49956, а третьего – 49968. Между первыми двумя 6 символов, а между следующими 12. Непорядок — вот и пропущенная строка.

Идем внутрь GetStartPositionOfLine():



Снова пропускаем стартовые проверки и смотрим на реальные действия. Сначала высчитывается точка, которая должна попасть на строку с номером lineIndex. Берется высота всех строк и прибавляется половинка высоты строки – для того, чтобы попасть в ее центр. На this.VerticalOffset и this.HorizontalOffset не смотрим – они по нулям.

Считаем в своем коде:

var lineHeight = (double) txt.InvokeMethod("GetLineHeight", null);
var y0 = lineHeight * (double)8510 + lineHeight / 2.0 - txt.VerticalOffset;
var y1 = lineHeight * (double)8511 + lineHeight / 2.0 - txt.VerticalOffset;
var y2 = lineHeight * (double)8512 + lineHeight / 2.0 - txt.VerticalOffset;

Значения разумные, с логикой соотносятся, все в порядке. Идем дальше по коду GetStartPositionOfLine() – нас интересует следующая осмысленная строка (первая внутри условия), которая похожа на крокодила и оканчивается вызовом GetTextPositionFromPoint().

Раскрываем вызовы и дергаем их через рефлексию. Обратим внимание, что некоторые интерфейсы нам недоступны из-за ограничения видимости, поэтому приходится ссылаться на них, используя все тот же Reflection.

var renderScope = (txt.GetFieldValue<FrameworkElement>("_renderScope") as IServiceProvider);
// 7 - тип интерфейся ITextView
var textView = renderScope.GetService(renderScope.GetType().GetInterfaces()[7]);
var o10 = textView.InvokeMethod("GetTextPositionFromPoint", new Point(-txt.HorizontalOffset, y0), true);
var o11 = textView.InvokeMethod("GetTextPositionFromPoint", new Point(-txt.HorizontalOffset, y1), true);
var o12 = textView.InvokeMethod("GetTextPositionFromPoint", new Point(-txt.HorizontalOffset, y2), true);

Полученные объекты показывают все те же смещения – 49950, 49956, 49568. Идем глубже, в реализацию GetTextPositionFromPoint() внутри TextBoxView.


Во, GetLineIndexFromPoint() выглядит многообещающе. Вызываем в своем коде.

var o20 = textView.InvokeMethod("GetLineIndexFromPoint", new Point(-txt.HorizontalOffset, y0), true);
var o21 = textView.InvokeMethod("GetLineIndexFromPoint", new Point(-txt.HorizontalOffset, y1), true);
var o22 = textView.InvokeMethod("GetLineIndexFromPoint", new Point(-txt.HorizontalOffset, y2), true);

Получаем 8510, 8511 и 8513 – бинго! К реализации:



Даже невооруженным взглядом видно, что это бинарный поиск. _lineMetrics – список характеристик строк (начало, длина, ширина границы). Радостно потираю ручки – я думал, что как это нередко бывает где-то забыли +1 воткнуть или поставили > вместо >=. Копируем функцию в код и отладим. Из-за закрытости типов _lineMetrics вытаскиваем через reflections, _lineHeight же мы уже достали раньше. Итого:

var lm = textView.GetFieldValue<object>("_lineMetrics");
var c = (int)lm.InvokeMethod("get_Count");
var lineMetrics = new List<Tuple<int,int,int,double>>();
for (var i = 0; i < c; i++)
{
    var arr_o = lm.InvokeMethod("get_Item", i);
    var contLength = arr_o.GetFieldValue<int>("_contentLength");
    var length = arr_o.GetFieldValue<int>("_length");
    var offset = arr_o.GetFieldValue<int>("_offset");
    var width = arr_o.GetFieldValue<double>("_width");
    lineMetrics.Add(new Tuple<int, int, int, double>(contLength, length, offset, width));
}
var o30 = GetLineIndexFromPoint(lineMetrics, lineHeight, new Point(-txt.HorizontalOffset, y0), true);
var o31 = GetLineIndexFromPoint(lineMetrics, lineHeight, new Point(-txt.HorizontalOffset, y1), true);
var o32 = GetLineIndexFromPoint(lineMetrics, lineHeight, new Point(-txt.HorizontalOffset, y2), true);

/*<...>*/

private int GetLineIndexFromPoint(List<Tuple<int, int, int, double>> lm, double _lineHeight, Point point, bool snapToText)
{
    if (point.Y < 0.0)
        return !snapToText ? -1 : 0;
    if (point.Y >= _lineHeight * (double)lm.Count)
    {
        if (!snapToText)
            return -1;
        return lm.Count - 1;
    }
    int index = -1;
    int num1 = 0;
    int num2 = lm.Count;
    while (num1 < num2)
    {
        index = num1 + (num2 - num1) / 2;
        var lineMetric = lm[index];
            double num3 = _lineHeight * (double)index;
        if (point.Y < num3)
            num2 = index;
        else if (point.Y >= num3 + _lineHeight)
        {
            num1 = index + 1;
        }
        else
        {
            if (!snapToText && (point.X < 0.0 || point.X >= lineMetric.Item4))
            {
                index = -1;
                break;
            }
            break;
        }
    }
    if (num1 >= num2)
        return -1;
    return index;
}

До отладки мы не добираемся. o30, o31 и o32 равны 8510, 8511 и 8512, соответственно. Такие какие и должны быть! Но o20, o21 и o22 с ними же не согласны. Как так? Мы же почти не поменяли код. Почти? И вот тут наступает озарение.

var lh = textView.GetFieldValue<double>("_lineHeight");

Вот она причина – разница 0.0009375. Причем если мы прикинем накопление ошибки — умножим на 8511, то получим 7.9790625. Это как раз около половины lineHeight, и поэтому при расчете координат точка вылетает за пределы нужной строки и попадает на следующую. Одна и та же переменная (по смыслу) подсчиталась двумя разными способами и, внезапно, не совпала.

На этом я решил остановиться. Возможно реально и докопаться почему высота столбца получилась разная, но я не вижу особого смысла. Сомнительно, что Microsoft будет это исправлять, поэтому смотрим на костыли для обхода. Reflection-костыль – устанавливать правильную _lineHeigh либо в одном, либо в другом месте. Звучит стремно, наверняка медленно и скорее всего ненадежно. Либо можно вести свой набор строк, параллельно TextBox’у и брать строки из него, благо получение номера строки по позиции курсора работает корректно.

Заключение

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

Пишите хороший код!

Другие статьи блога

> Машинное обучение в Offensive Security
Никакая машина меня не заменит. Мухаха-ха. Надеюсь.

> Где вставить кавычку в IPv6
Ребята знают куда и что впихнуть, чтобы стало хорошо. После таких слов меня все-таки заменят роботом, наверняка. СР! УВЧ!