Åtgärda enkla autentiseringsproblem i Outlook med MailKit och ASP.NET Core Web API

Förstå Outlook-autentiseringsproblem med ASP.NET Core och MailKit

När du integrerar Outlook e-postfunktioner i en ASP.NET Core webb-API med MailKit stöter utvecklare ofta på autentiseringsproblem. Ett vanligt problem är felmeddelandet "535: 5.7.139 Autentisering misslyckades". Detta inträffar vanligtvis när den grundläggande autentiseringsmetoden är inaktiverad på Outlook-servern, vilket gör att anslutningsförsöket misslyckas.

Grundläggande autentisering, som en gång använts i stor utsträckning, har i allt högre grad inaktiverats av tjänsteleverantörer som Microsoft för att förbättra säkerheten. Istället föredras moderna autentiseringsmetoder, som OAuth2. Denna förändring kan orsaka förvirring, särskilt för utvecklare som är vana vid att använda användarnamn och lösenord direkt.

I det här scenariot kan du ha använt rätt Outlook SMTP-serverinställningar och appspecifikt lösenord, men ändå stött på autentiseringsfel. Att förstå varför grundläggande autentisering misslyckas är avgörande för att lösa dessa problem effektivt. Felet indikerar en upprätthållande av säkerhetspolicyn snarare än ett problem med själva koden.

I den här artikeln kommer vi att utforska varför det här felet uppstår, de bakomliggande orsakerna och de steg du kan vidta för att lösa problemet. Vi kommer också att diskutera alternativa autentiseringsmetoder, såsom OAuth2, för att säkerställa säker och framgångsrik kommunikation med Outlooks servrar.

Utforska OAuth2-integration för säker e-postsändning

Skripten ovan är utformade för att ta itu med grundläggande autentiseringsfel påträffas när du skickar e-post via Outlooks SMTP-server med MailKit i ett ASP.NET Core Web API. Felet uppstår eftersom Microsoft har inaktiverat grundläggande autentisering för att förbättra säkerheten, vilket tvingar utvecklare att använda OAuth2, en säkrare autentiseringsmetod. I den första lösningen använde vi MailKit med OAuth2-tokens för att autentisera och skicka ett e-postmeddelande. Istället för att förlita sig på ett användarnamn och lösenord kräver OAuth2 en token, som genereras av Microsoft Identity Client (MSAL) och används för att autentisera förfrågningar på ett säkert sätt.

Till att börja med använder lösningen metoden `ConfidentialClientApplicationBuilder.Create()`, en del av MSAL-biblioteket, för att skapa en klientapplikation. Det här steget initierar applikationen med viktiga referenser som klient-ID, klient-ID och klienthemlighet, som krävs för att generera en OAuth2-token. När applikationen har byggts hämtar metoden `AcquireTokenForClient()` den token som behövs för att autentisera med Outlooks SMTP-server. Genom att använda mekanismen `SaslMechanismOAuth2()` kan MailKit sedan autentisera e-postsändningsprocessen med denna token, och helt förbigå grundläggande autentisering. Denna metod säkerställer att applikationen följer moderna säkerhetsprotokoll och undviker föråldrade metoder.

I den andra lösningen används Microsoft Graph API för att skicka e-postmeddelanden utan att direkt interagera med SMTP-servern. Microsoft Graph tillhandahåller en allt-i-ett-lösning för att hantera Microsoft-tjänster, inklusive Outlook-e-post. Graph API utnyttjar OAuth2-autentisering genom `DelegateAuthenticationProvider()`, som tilldelar en OAuth2-token till varje begäran. Denna token genereras på liknande sätt med MSAL. "GraphServiceClient"-objektet underlättar säker kommunikation med Microsofts servrar, vilket gör att API:et kan skicka e-post sömlöst. Den här metoden är särskilt användbar för dem som vill hantera en bredare uppsättning Microsoft-tjänster med färre direktanslutningar till enskilda tjänster som SMTP.

Slutligen, i den tredje lösningen, utforskade vi ett mer traditionellt tillvägagångssätt med den inbyggda System.Net.Mail namnutrymme för .NET. Även om den fortfarande använder OAuth2 för autentisering, ersätter den här metoden MailKit med System.Net.Mails SMTP-klient för att skicka e-post. OAuth2-token skickas in som en autentiseringsinformation istället för den vanliga kombinationen av användarnamn och lösenord. E-postmeddelandet är konstruerat och skickat med de typiska `MailMessage`- och `SmtpClient`-objekten. Detta tillvägagångssätt kan vara användbart för utvecklare som föredrar att arbeta med inhemska .NET-bibliotek men som fortfarande kräver säker OAuth2-autentisering för att skicka e-post.

Alla dessa metoder löser inte bara problemet med att grundläggande autentisering är inaktiverad utan också framtidssäkrar e-postsändningsfunktionen i ditt ASP.NET Core Web API. Varje lösning lyfter fram vikten av säkerhet genom OAuth2, som ersätter föråldrade och mindre säkra autentiseringsmetoder. Genom att utnyttja moderna autentiseringsbibliotek som MSAL och Microsoft Graph kan utvecklare säkerställa att deras applikationer förblir kompatibla med de senaste säkerhetsstandarderna, samtidigt som de erbjuder tillförlitliga e-postsändningsmöjligheter.

// Step 1: Install required NuGet packages
// MailKit, MimeKit, and Microsoft.Identity.Client for OAuth2

using MailKit.Net.Smtp;
using MimeKit;
using Microsoft.Identity.Client;

// Step 2: Configure OAuth2 authentication
var clientId = "your-client-id";
var tenantId = "your-tenant-id";
var clientSecret = "your-client-secret";

var cca = ConfidentialClientApplicationBuilder
    .Create(clientId)
    .WithClientSecret(clientSecret)
    .WithAuthority(new Uri($"https://login.microsoftonline.com/{tenantId}"))
    .Build();

var scopes = new[] { "https://outlook.office365.com/.default" };
var result = await cca.AcquireTokenForClient(scopes).ExecuteAsync();

// Step 3: Send email using OAuth2 token
var emailMessage = new MimeMessage();
emailMessage.From.Add(new MailboxAddress("Your Name", "your-email@outlook.com"));
emailMessage.To.Add(new MailboxAddress("Recipient", "recipient@example.com"));
emailMessage.Subject = "Subject";
emailMessage.Body = new TextPart("plain") { Text = "Hello, this is a test email." };

using (var smtpClient = new SmtpClient())
{
    await smtpClient.ConnectAsync("smtp.office365.com", 587, SecureSocketOptions.StartTls);
    await smtpClient.AuthenticateAsync(new SaslMechanismOAuth2("your-email@outlook.com", result.AccessToken));
    await smtpClient.SendAsync(emailMessage);
    await smtpClient.DisconnectAsync(true);
}

// Step 1: Add Microsoft.Graph NuGet package
using Microsoft.Graph;
using Microsoft.Identity.Client;

// Step 2: Configure Graph API and authentication
var confidentialClient = ConfidentialClientApplicationBuilder.Create(clientId)
    .WithTenantId(tenantId)
    .WithClientSecret(clientSecret)
    .Build();

var graphClient = new GraphServiceClient(new DelegateAuthenticationProvider(async (requestMessage) =>
{
    var authResult = await confidentialClient.AcquireTokenForClient(scopes).ExecuteAsync();
    requestMessage.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authResult.AccessToken);
}));

// Step 3: Prepare and send email via Graph API
var message = new Message
{
    Subject = "Test Email",
    Body = new ItemBody
    {
        ContentType = BodyType.Text,
        Content = "Hello, this is a test email sent via Microsoft Graph API."
    },
    ToRecipients = new List<Recipient>()
    {
        new Recipient { EmailAddress = new EmailAddress { Address = "recipient@example.com" } }
    }
};

await graphClient.Users["your-email@outlook.com"].SendMail(message, false).Request().PostAsync();

// Step 1: Configure OAuth2 with System.Net.Mail
var smtpClient = new SmtpClient("smtp.office365.com")
{
    Port = 587,
    EnableSsl = true,
    UseDefaultCredentials = false,
    Credentials = new NetworkCredential("your-email@outlook.com", accessToken)
};

// Step 2: Construct the email message
var mailMessage = new MailMessage
{
    From = new MailAddress("your-email@outlook.com"),
    Subject = "Test Email",
    Body = "This is a test email sent using System.Net.Mail with OAuth2.",
    IsBodyHtml = true
};

mailMessage.To.Add("recipient@example.com");

// Step 3: Send the email
await smtpClient.SendMailAsync(mailMessage);

Implementering av moderna säkerhetsstandarder för e-postsändning

I samband med moderna e-postsystem ses grundläggande autentisering alltmer som föråldrad och osäker. Detta gäller särskilt för stora tjänsteleverantörer som Outlook, som har inaktiverat grundläggande autentisering för att genomdriva säkrare mekanismer som OAuth2. Grundläggande autentisering, som enbart förlitar sig på ett användarnamn och lösenord, är sårbart för brute force-attacker och kan äventyras om referenser stjäls. Att byta till OAuth2, som Microsoft uppmuntrar, säkerställer därför att tokens utbyts säkert utan att användarens autentiseringsuppgifter exponeras.

En avgörande aspekt av att implementera OAuth2 är konceptet med åtkomsttokens. Istället för att förlita sig på direkt autentisering via SMTP-servrar, utfärdar OAuth2 tidsbundna tokens som tillåter säker åtkomst till resurser som e-posttjänster. Dessa tokens beviljas av en auktoriseringsserver och utvecklare kan få dem med hjälp av bibliotek som Microsoft Identity Client (MSAL). Med dessa tokens får applikationer begränsad åtkomst till användarens konto, vilket minskar riskerna förknippade med långvariga, statiska autentiseringsuppgifter.

Att använda OAuth2 anpassar dessutom inte bara din applikation till modern säkerhetspraxis utan förbereder den också för framtida utveckling. Många API:er, inklusive de för molnbaserade tjänster, är nu starkt beroende av OAuth2 för säker kommunikation. Detta säkerställer att e-postsändningsfunktionen förblir funktionell och säker när tjänsterna utvecklas. För utvecklare som integrerar MailKit med ASP.NET Core, att använda OAuth2 ger en rad säkerhetsförbättringar, från token-baserad autentisering till krypterade överföringar via protokoll som STARTTLS.