.NET Разработчик

2022-08-30 07:01:14 День 1308. #ЗаметкиНаПолях
Принудительный HTTPS в Приложениях ASP.NET Core. Начало
Как заставить ваше приложение ASP.NET Core использовать только HTTPS? Изучаем лучшие практики для различных сценариев.

1. Использовать перенаправление HTTPS
Если клиент вызывает приложение, используя HTTP, приложение перенаправляет его на тот же URL-адрес, начинающийся с HTTPS. Перенаправление URL — хорошо известный подход. Веб-приложение создает ответ HTTP с кодом состояния, начинающимся с 3, и заголовком Location, как в следующем примере:
HTTP/1.1 301 Moved Permanently
Location: https://...

Этот подход не устраняет все риски безопасности, но является хорошей отправной точкой. К счастью, в ASP.NET Core есть несколько других вариантов.

2. Атрибут RequireHttps
Его можно использовать в приложениях, чтобы заставить страницу требовать HTTPS. В Razor Pages RequireHttps можно применять только к классам, страниц, либо к методам класса:
[RequireHttps]
public class PrivacyModel : PageModel
{ … }

В ASP.NET Core MVC можно применить атрибут RequireHttps к классам, контроллеров или к их методам действия:
[RequireHttps]
public class HomeController : Controller
{ … }

Есть соблазн применять атрибут выборочно к определённым страницам или представлениям, таким образом ограничить HTTPS только страницами с конфиденциальным содержимым. Но смешивание страниц HTTP и HTTPS — очень плохая идея! Ваше приложение так подвергается атакам с понижением протокола. Это разновидность атак man-in-the-middle, когда HTTP запрос перехватывается атакующим, и таким образом компрометируется вся безопасность последующей коммуникации между клиентом и сервером.
Можно применить RequireHttps ко всем страницам, но есть и более простые способы.

3. Промежуточное ПО перенаправления на HTTPS
При создании веб-приложения с использованием одного из стандартных шаблонов проектов ASP.NET файл Program.cs (Startup.cs) содержит вызов метода UseHttpsRedirection() в конвейере промежуточного ПО:
…
app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();
…
Вызов метода UseHttpsRedirection() означает, что каждый запрос к вашему приложению будет проверен и, возможно, перенаправлен промежуточным ПО. Все страницы вашего приложения будут требовать HTTPS.

4. Промежуточное ПО HSTS
К сожалению, принудительного переключения клиента с HTTP на HTTPS при каждом запросе может быть недостаточно для предотвращения атак с понижением протокола. Злоумышленник может перехватить HTTP-запрос клиента до того, как он переключится на соответствующий HTTPS-запрос.
Нужен способ указать браузеру обязательно использовать HTTPS для запроса любого ресурса веб-приложения. Это заголовок HTTP Strict-Transport-Security (HSTS). Имея заголовок HSTS, браузер будет вызывать ваше приложение с использованием HTTP только в самый первый раз. Последующие запросы к тому же домену будут выполняться через HTTPS, даже если в адресе будет HTTP. Включить HSTS можно с помощью метода UseHsts(). Этот вызов также уже включён в шаблоны веб-приложений ASP.NET Core:
if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}

По умолчанию поддержка HSTS отключена в вашей среде разработки. Скорее всего, вы используете localhost в качестве домена. Если вы используете HSTS, любой запрос, сделанный вашим браузером к локальному хосту, будет использовать HTTPS. Это является хорошей практикой. Но при этом браузер будет делать HTTPS-запросы к любому приложению, размещённому на локальном хосте. Это может вызвать проблемы, например с Angular приложениями.

Окончание следует…

Источник: https://auth0.com/blog/force-https-in-aspnet-core-apps/ Открыть/Комментировать

2022-08-29 07:47:20 Открыть/Комментировать

2022-08-29 07:47:14 День 1307. #Книги
Прочитал книгу «Принципы юнит-тестирования» (Владимир Хориков — СПб.: Питер, 2022).

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

В книге довольно подробно описана теория: что такое тесты, какие они бывают, из чего состоят, зачем их делать и какие правила стоит соблюдать, а чего лучше не делать (например, что не стоит гнаться за метриками покрытия кода). Вообще, на канале отрывков из книги приводилось уже довольно много. Их можно найти по тегу #Testing. А вот здесь есть даже шпаргалка по юнит-тестам, по мотивам книги.

Что не совсем понравилось. На мой взгляд примеры в книге слишком упрощены. Я понимаю, что невозможно в печатном издании приводить многостраничные листинги кода. Но, например, в книге «Внедрение зависимостей на платформе .NET», на которую Владимир частенько ссылается, авторам удалось привести примеры реальных приложений и реальных проблем, с которыми можно столкнуться. Здесь же, как мне показалось, примеры приводятся слишком простые, и часто за ними следует фраза вроде «понятно, что в реальных системах всё будет намного сложнее».

В чём я лично вижу проблему с переупрощёнными примерами. Требуется опыт, чтобы придумать, где это будет применено в реальности. А это нужно, чтобы кусочек пазла встал на своё место. У меня с этим проблем не возникло, потому что я в последнее время всерьёз занялся внедрением тестов на своей основной работе (собственно, поэтому и книгу приобрёл). Я уже столкнулся с большинством описанных препятствий, поэтому у меня они «легли в контекст», и я довольно часто ловил себя на мысли «а, так вот как это надо было делать». Или же я легко представлял, где я смогу это использовать.

Однако у человека, не имеющего хотя бы небольшого опыта в тестировании серьёзного приложения, как мне кажется, может возникнуть проблема с обоснованием нужности того или иного утверждения из книги. А когда факт зависает вне контекста, не отвечая на вопрос «зачем?», он быстро забывается. Хотя, в этом случае можно посоветовать прочитать книгу, узнать основы, а затем перелистать её после получения некоторой реальной практики (и пары шишек). Открыть/Комментировать

2022-08-28 08:17:12 День 1306. #TypesAndLanguages
7. Инкапсуляция или Публичное Всё
Сейчас немного разожгу:
Всё должно быть публичным. Не используйте модификатор private вообще.

А теперь давайте обсудим это немного подробнее.

Одно из свойств инкапсуляции состоит в сокрытии внутреннего устройства. Это может выражаться в различных формах. Самая простая из них — геттеры и сеттеры. Мы делаем поля приватными, а затем открываем методы доступа для чтения и записи. Однако всё может быть общедоступным, и при этом мы всё равно можем скрывать внутренности. Как это возможно?

Бывают ситуации, когда нам нужно получить доступ к некоторым внутренним элементам или изменить их. Либо напрямую, либо через рефлексию, либо через взлом памяти. Проблема в том, что в большинстве случаев компиляторы нам не помогут в таких ситуациях. Компиляторы не будут проверять вашу рефлексию, верна она у вас или нет. Они не остановят компиляцию вашего небезопасного низкоуровневого кода, если он неверен. Это значительно усложняет работу с внутренними компонентами, поскольку они могут быть изменены практически в любое время, а у нас нет механизма, позволяющего обнаружить, что изменение нарушает наш код. Однако такой проблемы не бывает, когда всё публично. Если вы обращаетесь к внутренним компонентам напрямую, компилятор сообщит вам, когда произойдёт критическое изменение. Это позволяет находить ошибки намного раньше и намного проще.

Но как мы можем скрывать внутренности, когда всё публично? Ответ: представления. С помощью различных представлений, которые в большинстве языков реализованы через интерфейсы, мы можем предоставлять абстракцию, но по-прежнему иметь доступ к внутренним компонентам. Представьте, что у нас есть следующий класс:
class Foo {
public void Bar() { … }
private void BarInternals() { … }
}

Можно сказать, что это хорошо, потому что класс скрывает BarInternals, делая его приватным. Таким образом, вызывающая сторона не может получить доступ к внутренним компонентам и не нарушит их. Однако можно использовать интерфейсы:
interface IFoo {
void Bar();
}
class Foo : IFoo {
public void Bar() { … }
public void BarInternals() { … }
}

Теперь любой «порядочный» клиент, вызывающий объект, должен использовать Foo через интерфейс IFoo, поэтому метод BarInternals останется недоступным. Дело не в том, что он приватный или доступ заблокирован контроллером политик. Метода просто нет! Однако, если кому-то нужно схитрить, он может привести IFoo к Foo и получить поддержку компилятора, чтобы убедиться, что BarInternals существует.

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

Примечание: От себя добавлю, что делать совсем всё публичным, наверное, чересчур радикально. На моей практике доступ к внутренностям нужен не так часто, поэтому такой проблемы обычно не возникает. Но в принципе, подход с сокрытием через интерфейс интересный.

Что скажете?

Источник: https://blog.adamfurmanek.pl/2022/07/23/types-and-programming-languages-part-16/
Автор оригинала: Adam Furmanek Открыть/Комментировать

2022-08-27 07:27:55 День 1305. #Оффтоп #Юмор
Сегодня порекомендую вам крайне познавательный и, в то же время, уморительный доклад Марка Рендла “Programming’s Greatest Mistakes” (Величайшие ошибки в программировании)

с конференции NDC Copenhagen 2022, прошедшей с 30 мая по 2 июня.

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

Марк описывает некоторые из самых серьёзных ошибок в истории программирования. Узнайте, что пошло не так, почему это пошло не так, сколько это стоило и насколько забавны вещи, когда они происходят не с вами.

Кстати, если вы допустили серьёзную ошибку, и не знаете, как теперь быть, прочитайте этот пост. Открыть/Комментировать

2022-08-26 09:25:55 Открыть/Комментировать

2022-08-26 08:30:31 День 1304. #Карьера
Как Разработчику ПО Развить Навыки Решения Проблем
Общеизвестно, что решение проблем является важным навыком для инженеров-программистов. Хорошие навыки решения проблем включают в себя способность мыслить творчески и аналитически, разбивая проблемы на более мелкие части и используя системный подход для поиска решений. Сильные навыки решения проблем необходимы для успешной карьеры в разработке ПО.

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

Разделяй и властвуй
Другой подход заключается в использовании более системного метода.
Метод «Разделяй и властвуй» подходит для решения сложных проблем путём их разбиения на более мелкие, управляемые части. Это позволяет более эффективно и действенно решать проблемы. Как только эти подзадачи решены, их можно объединить для решения более крупной и сложной проблемы.
Среди распространённых примеров «разделяй и властвуй»: рекурсия или алгоритм сортировки слиянием, который разбивает массив на более мелкие части, сортирует каждую часть, а затем объединяет их.

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

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

1. Аналитические навыки
Это способность собирать и анализировать данные, выявлять закономерности и тенденции и принимать решения на основе этой информации. Они предполагают как логическое, так и творческое мышление, а также способность обращать внимание на детали. Некоторые примеры:
- Умение разбить проблему и идентифицировать различные компоненты,
- Умение определять закономерности и тенденции,
- Умение видеть связи между различными частями данных,
- Умение принимать решения на основе данных,
- Умение решать сложные задачи.

2. Креативное мышление
В компьютерных науках оно связано с поиском новых и инновационных способов решения проблем. Речь идёт о нестандартном мышлении и поиске креативных решений, о которых раньше никто не думал. В ИТ важно проявлять творческий подход, потому что это постоянно развивающаяся область. Если вы не будете постоянно генерировать новые идеи, вы отстанете. Креативное мышление — это то, что заставляет информатику двигаться вперед.

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

Итого
Практика — один из лучших способов улучшить свои навыки решения проблем.
Вы можете делать это, работая над задачами по кодированию, участвуя в онлайн-конкурсах или просто пытаясь решить проблемы, с которыми вы сталкиваетесь в своей повседневной работе.
Сотрудничество — ещё один отличный способ улучшить свои навыки решения проблем. Когда вы работаете с другими, вы можете учиться на их опыте и делиться своими мыслями. Это может помочь вам выработать более качественный подход к решению проблем.

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

Источник: https://dev.to/nathan20/how-to-develop-strong-problem-solving-skills-as-a-software-developer-25nb Открыть/Комментировать

2022-08-25 08:34:01 День 1303. #ЧтоНовенького
Построчный Git Stage в Visual Studio 17.3
Я уже писал про этот функционал в обзоре новых функций превью версии 17.2. Напомню, построчный или интерактивный Git Stage, позволяет разделить изменённые строки в одном файле в разные коммиты. Его также можно использовать для проверки ваших изменений перед их фиксацией. Отметьте изменённые строки или разделы кода как проверенные, поместив их в Stage, и зафиксируйте эти изменения, когда закончите проверку.
Теперь этот функционал выпущен в VS версии 17.3, а Microsoft выпустили видео с пошаговой инструкцией по использованию. По-моему, очень удобно.

Источник: https://devblogs.microsoft.com/visualstudio/git-line-staging-released/ Открыть/Комментировать

2022-08-24 07:34:40 День 1302. #ЗаметкиНаПолях
Выполнение Скриптов на C# и .NET Core
Вы, вероятно, знаете, что в .NET Core очень легко создать новое приложение «Hello World» и начать писать код. Просто установите .NET Core, затем выполните dotnet new console, что сгенерирует файл проекта и базовое приложение, затем dotnet run скомпилирует и запустит его. Команда new создаст весь вспомогательный код, папки obj, bin и т. д. Когда вы выполняете dotnet run, на самом деле это комбинация команд dotnet build и dotnet exec myapp.dll.

Что может быть проще? А что насчёт сценариев в .NET Core?

На помощь придёт инструмент сценариев dotnet-script.
Для начала установим инструмент:
>dotnet tool install -g dotnet-script

Создадим файл скрипта helloworld.csx со следующим содержимым:
Console.WriteLine("Hello world!");

Теперь его можно выполнить:
>dotnet script helloworld.csx
Hello world!

Замечание: Если вы будете это делать в Linux или OSX, вам нужно будет указать в первой строке стандартный заголовок, говорящий о том, какая программа может исполнять этот скрипт:
#!/usr/bin/env dotnet-script

Заголовок аналогичен файлам bash, python и т.п.

Скрипты могут иметь классы и подпрограммы. Заметьте, выражения верхнего уровня (без этих ваших Program и Main) использовались здесь ещё задолго до того, как это стало мейнстримом:
using System.Collections.Generic;
using System.Linq;

foreach (var i in Fibonacci().Take(20))
{
Console.WriteLine(i);
}

private IEnumerable Fibonacci()
{
int current = 1, next = 1;

while (true)
{
yield return current;
next = current + (current = next);
}
}

Если нужно, вы можете обратиться к NuGet пакету внутри скрипта, используя синтаксис #r от Roslyn:
#r "nuget: AutoMapper, 6.1.0"
Console.WriteLine("Hello AutoMapper!");

Но и это ещё не всё. Имея dotnet-script, установленный как глобальная утилита, как мы сделали выше, вы можете использовать его как REPL (интерактивную среду) прямо в консоли!
>dotnet script
> 2+2
4
> var x = "dotnet script";
> x.ToUpper()
"DOTNET SCRIPT"

Источник: https://www.hanselman.com/blog/c-and-net-core-scripting-with-the-dotnetscript-global-tool

966 views04:34

Открыть/Комментировать

2022-08-23 09:14:06 День 1301. #ЗаметкиНаПолях #AsyncTips
Внедрение Запросов на Отмену

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

Решение
В системе отмены .NET предусмотрена встроенная поддержка этого сценария в виде связанных токенов отмены. Источник токена отмены может быть создан связанным с одним (или несколькими) существующими токенами. Когда вы создаёте источник связанного токена отмены, полученный токен будет отменяться при отмене любых из существующих токенов или при явной отмене связанного источника.

Следующий пример выполняет асинхронный запрос HTTP. Токен, переданный методу GetWithTimeoutAsync, представляет отмену, запрошенную конечным пользователем, а метод GetWithTimeoutAsync также применяет тайм-аут к запросу:
async Task
GetWithTimeoutAsync(
HttpClient client,
string url,
CancellationToken ct)
{
using var cts = CancellationTokenSource
.CreateLinkedTokenSource(ct);
cts.CancelAfter(TimeSpan.FromSeconds(2));

var combined = cts.Token;
return await client.GetAsync(url, combined);
}

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

Хотя в предыдущем примере используется только один источник CancellationToken, метод CreateLinkedTokenSource может получать любое количество токенов отмены в своих параметрах. Это позволяет создавать один объединённый токен, на базе которого можно реализовать собственную логическую отмену. Например, ASP.NET предоставляет токен отмены, представляющий отключение пользователя (HttpContext.RequestAborted); код обработчика может создать связанный токен, который реагирует либо на отключение пользователя, либо на свои причины отмены (например, тайм-аут).

Помните о сроке существования источника связанного токена отмены. Предыдущий пример является наиболее типичным: один или несколько токенов отмены передаются методу, который связывает их и передает как комбинированный токен. Также обратите внимание на то, что в примере используется команда using, которая гарантирует, что источник связанного токена отмены будет освобожден, когда операция будет завершена (а комбинированный токен перестанет использоваться). Подумайте, что произойдет, если код не освободит источник связанного токена отмены: может оказаться, что метод GetWithTimeoutAsync будет вызван несколько раз с одним (долгосрочным) существующим токеном; в этом случае код будет связывать новый источник токена при каждом вызове метода. Даже после того, как запросы HTTP завершатся (и ничто не будет использовать комбинированный токен), этот связанный источник всё ещё останется присоединённым к существующему токену. Чтобы предотвратить подобные утечки памяти, освобождайте источник связанного токена отмены, когда комбинированный токен перестаёт быть нужным.

Источник: Стивен Клири “Конкурентность в C#”. 2-е межд. изд. — СПб.: Питер, 2020. Глава 10.

972 views06:14

Открыть/Комментировать