diff --git a/themes/terminal/layouts/_default/single.html b/themes/terminal/layouts/_default/single.html
index 3d375ad..a90eecf 100644
--- a/themes/terminal/layouts/_default/single.html
+++ b/themes/terminal/layouts/_default/single.html
@@ -5,7 +5,7 @@
{{ if .Params.Date }}
- {{ .Date.Format "2006-01-02" }}
+ {{ .Date | time.Format ":date_long" }}
{{ if $.Site.Params.showLastUpdated }}
[{{or $.Site.Params.updatedDatePrefix "Updated"}}: {{ .Lastmod.Format "2006-01-02" }}]
{{ end }}
diff --git a/themes/terminal/layouts/partials/head.html b/themes/terminal/layouts/partials/head.html
index 09f6011..66ae175 100644
--- a/themes/terminal/layouts/partials/head.html
+++ b/themes/terminal/layouts/partials/head.html
@@ -28,12 +28,23 @@
{{- end }}
-
+ Reach me
+
+
+ 
+
+
+ 
+
+
+
+We will clone this repo to our computer, move the code that we write into this repo folder and push the codes to origin.
+
+
+
+```bash
+git add .
+git commit -m "inital commit"
+git push origin
+```
+
+
+
+## Azure DevOps build pipeline
+
+On the Pipeline screen, we click on the New pipeline button from the top right. Then, we build the docker file and push it to Azure Container Registry by following the steps below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Now we check that our image deployment in Azure Container Registry is successful.
+
+
+
+
+
+
+
+As we can see, when the pipeline is run, the docker image has been successfully created in the Azure Container Registry and is waiting to be used. After these settings, a new docker image will be created by triggering every change made in the /backend directory on the main branch.
+
+## Azure App service
+
+Azure App service allows us to deploy web applications with security, load balancing, autoscaling managed by Azure itself. We can create a new app service via the Azure app services screen as follows.
+
+
+
+
+
+
+
+
+
+
+
+After creating the app service, you may need to update the Container Registry password from the configuration tab.
+
+## Azure DevOps release pipeline
+
+With the release pipeline, we deploy to the App service using the Docker image produced by the build pipeline and publish our application.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+By going into staging deployment, we get deployment for our staging version and restart our app service to ensure that the docker image change we made goes live.
+
+
+
+
+
+
+
+
+
+
+
+
+
+In our production step, we do not take a deployment to the app service, instead we perform the swap operation with staging and in this way, we start running our application running in staging in production without experiencing any downtime.
+
+
+
+
+
+
+
+
+
+From now on, any changes made to the main branch will first run the build pipeline (CI), then the deployment pipeline (CD), and deployment will be made to the staging environment. If you want to switch to Production, Production deployment must be triggered manually from the release screen.
+
+
+
+## Zero downtime testing
+
+We have successfully created a pipeline for our application, from now on we will need to test whether there is any downtime during deployment. For this, I update our _health-check/index.js_ file as follows and run the application with the npm run start command and trigger the pipeline. And then I complete the deployment process without receiving any error messages on the console, that is, without any downtime!
+
+```js
+import fetch from "node-fetch";
+
+const check = async (url) => {
+ try {
+ const response = await fetch(url, {
+ method: "GET",
+ });
+ const result = await response.text();
+
+ if (result !== "Healthy") {
+ console.log(`${new Date().toISOString()}, ${url} result is not OK`);
+ }
+ } catch (error) {
+ console.log(`${new Date().toISOString()}, ${url} error is ${error.message}`);
+ }
+};
+
+(() => {
+ setInterval(() => {
+ check("https://deployment-slot-demo.azurewebsites.net/health");
+ }, 50);
+ setInterval(() => {
+ check("https://deployment-slot-demo-staging.azurewebsites.net/health");
+ }, 50);
+})();
+```
+
+If we try a similar process in an app service deployment that does not implement deployment slots, we will receive an error as follows.
+
+```bash
+2023-11-14T12:28:39.506Z, [some-url]/health error is request to [some-url]/health failed, reason: connect ETIMEDOUT 100.100.100.100:443
+```
+
+---
+
+## Conclusion
+
+Thank you for reading 🎉 Don't miss out on the latest updates and insights in the world of software development. Follow me on [@berkslv](https://x.com/berkslv) to stay connected and join the conversation
\ No newline at end of file
diff --git a/content/english/posts/background-jobs-and-hangife-in-net.md b/content/english/posts/background-jobs-and-hangife-in-net.md
new file mode 100644
index 0000000..be36687
--- /dev/null
+++ b/content/english/posts/background-jobs-and-hangife-in-net.md
@@ -0,0 +1,398 @@
++++
+title = "Background jobs and Hangfire in .Net"
+date = "2024-09-17T00:00:00+03:00"
+author = "Berk Selvi"
+authorTwitter = "berkslv" #do not include @
+keywords = [".NET","hangfire","background jobs"]
+description = "Learn about managing background jobs in .Net with various methods like Task.Run(), Hosted Service, and Hangfire. This comprehensive blog post explores their pros, cons, and implementation details, with a focus on Hangfire..."
+showFullContent = false
+readingTime = true
++++
+
+
+When developing an application in the .Net ecosystem, when things get complicated, we may need some of our methods to go to multiple services, evaluate their responses, and report these results to different services and this takes long time! We do not want to waste resources by placing such long-running methods behind an endpoint and keeping our TCP connection open for the response from that HTTP request. We can call this usage on demand job because it will run when a request is made. We may also want it to run automatically at certain times of the day or week, without putting it behind an endpoint; in this case, we can call it a recurring job. In such cases, we use “background job” by starting our work on a different thread other than the main thread where the application runs.
+
+There are many different methods of managing background jobs in .Net. This will be a blog post where I will talk about them step by step, how they solve problems and what problems they cause us, and give in-depth usage examples in Hangfire, which is the package I like the most when dealing with background jobs. You can also access all the codes from the repo:
+
+[GitHub - berkslv/lecture-dotnet-background-jobs](https://github.com/berkslv/lecture-dotnet-background-jobs)
+
+
+## Task.Run()
+
+
+We can create a new thread and run a method on it with the Task.Run() method, which is the first solution that comes to my mind when I need a background job. I have a method that has dependencies on many external services that can take up to 5 minutes to complete, and I was calling this method with an HTTP request through a controller that I created, but answering this request was problematic because it is required a TCP connection to remain open for 5 minutes, so instead when I called the method, If started successfully, I had to notify the client that the process was started successfully with a 200 status code.
+
+```cs
+// TestService.cs
+
+public class TestService : ITestService
+{
+ private readonly ILogger
+
+
+
+
+
+After logged in we create new realm for managing users and client for our application from this dropdown menu. After clicking the Create realm button, simply enter the **secured** as the realm name and leave everything as is.
+
+
+
+In clients tab click Create client. name Client ID as **postman** and valid redirect uri as [**https://oauth.pstmn.io/v1/callback**](https://oauth.pstmn.io/v1/callback). leave other things as is.
+
+
+
+In the users tab, add users to log in to Keycloak.
+
+
+
+After these steps we can login to our keycloak with newly created user to get access token. For accessing API gateway I use Postman. In postman you can logged in with Keycloak. In Authorization section select OAuth 2.0 and configure as follows and click Get New Access Token. Postman will open browser window and redirect you to Keycloak login page, enter credentials for your new user. Don’t enter admin credentials, this credentials only valid in master realm.
+
+```txt
+Grant type: Authorization code
+Auth URL: http://localhost:5050/identity/realms/secured/protocol/openid-connect/auth
+Access Token URL: http://localhost:5050/identity/realms/secured/protocol/openid-connect/token
+Client ID: postman
+Scope: openid profile roles
+```
+
+If you did everything right, you have successfully authenticated using Postaman with Keycloak behind the API Gateway 🎉
+
+## Authenticate requests to other services
+
+If you want to authenticate a request in Ocelot, make the following updates to Program.cs and ocelot.json. MetadataAddress gets the keys required for JWT validation. However, if you want to avoid extra network calls, you can place the keys in the appsettings.json file and use them.
+
+Authentication completed with AuthenticationOptions in ocelot.json file, here we say that we will send our JWT token along with the Bearer prefix and JWT token validation done with configuration from Program.cs
+
+```cs
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services
+ .AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
+ .AddJwtBearer(JwtBearerDefaults.AuthenticationScheme, o =>
+ {
+ o.MetadataAddress = "http://localhost:5050/identity/realms/secured/.well-known/openid-configuration";
+ o.RequireHttpsMetadata = false;
+ o.Authority = "http://localhost:5050/realms/secured";
+ o.Audience = "account";
+ });
+
+builder.Configuration.AddJsonFile("ocelot.json", optional: false, reloadOnChange: true);
+
+
+builder.Services.AddOcelot(builder.Configuration);
+
+var app = builder.Build();
+
+app.UseAuthentication();
+app.UseAuthorization();
+
+await app.UseOcelot();
+await app.RunAsync();
+```
+
+```json
+{
+ "Routes": [
+ {
+ "DownstreamPathTemplate": "/get",
+ "DownstreamScheme": "https",
+ "DownstreamHostAndPorts": [
+ {
+ "Host": "httpbin.org",
+ "Port": 443
+ }
+ ],
+ "UpstreamPathTemplate": "/test",
+ "UpstreamHttpMethod": [ "Get" ],
+ "AuthenticationOptions": {
+ "AuthenticationProviderKey": "Bearer"
+ }
+ },
+
+//...
+```
+
+## Authorize requests to other services
+
+Authorization is slightly more difficult and requires additional work because Keycloak place user roles in nested form in JWT payload. It is something like following. As you can see roles field is placed under realm_access field. This creates confusion in Ocelot, because Ocelot reads claims as string or object values and does not evaluate nested fields. To avoid this problem we configure Keycloak token mapper and don’t use nested form.
+
+```json
+{
+ //...
+ "exp": 1706600524,
+ "realm_access": {
+ "roles": [
+ "offline_access",
+ "default-roles-microcommerce",
+ "uma_authorization",
+ "customer"
+ ]
+ },
+ "resource_access": {
+ "account": {
+ "roles": [
+ "manage-account",
+ "manage-account-links",
+ "view-profile"
+ ]
+ }
+ },
+ "scope": "openid email profile",
+ "preferred_username": "berkslv",
+}
+```
+
+For this custom mapping, click Client scopes from left menu and select roles.
+
+
+
+Under the roles, select Mappers section and then click realm roles.
+
+
+
+In the menu that opens, realm_access.roles is entered in the Token Claim Name option. We update this to **realm_roles**.
+
+
+
+After making these configurations, we update our token by logging in again via Postman. We make the following update in the ocelot.json file so that the requests we make with the updated token are subject to claim control by Ocelot. If we don’t have **customer** role in our user we get 403 response. You can create and assing your custom roles in Keycloak admin panel.
+
+```json
+{
+ "Routes": [
+ {
+ "DownstreamPathTemplate": "/get",
+ "DownstreamScheme": "https",
+ "DownstreamHostAndPorts": [
+ {
+ "Host": "httpbin.org",
+ "Port": 443
+ }
+ ],
+ "UpstreamPathTemplate": "/test",
+ "UpstreamHttpMethod": [ "Get" ],
+ "AuthenticationOptions": {
+ "AuthenticationProviderKey": "Bearer"
+ },
+ "RouteClaimsRequirement": {
+ "realm_roles": "customer"
+ }
+ },
+
+//...
+```
+
+If you want to access the source code, you can find the whole project on my GitHub account:
+
+[GitHub - berkslv/lecture-ocelot-and-keycloak](https://github.com/berkslv/lecture-ocelot-and-keycloak)
+
+---
+
+## Conclusion
+
+Thank you for reading 🎉 Don't miss out on the latest updates and insights in the world of software development. Follow me on [@berkslv](https://x.com/berkslv) to stay connected and join the conversation
\ No newline at end of file
diff --git a/content/english/posts/how-to-use-rsa-for-encryption-in-javascript-and-decryption-in-net.md b/content/english/posts/how-to-use-rsa-for-encryption-in-javascript-and-decryption-in-net.md
new file mode 100644
index 0000000..9049839
--- /dev/null
+++ b/content/english/posts/how-to-use-rsa-for-encryption-in-javascript-and-decryption-in-net.md
@@ -0,0 +1,350 @@
++++
+title = "How to Use RSA for Encryption in JavaScript and Decryption in .NET"
+date = "2024-03-07T00:00:00+03:00"
+author = "Berk Selvi"
+authorTwitter = "berkslv" #do not include @
+keywords = ["rsa", "cryptography", ".NET", "security"]
+description = "In the digital world, securing communication between different systems is paramount. RSA encryption is an asymmetric encryption algorithm and provides a robust way to achieve this by using a pair of…"
+showFullContent = false
+readingTime = true
++++
+
+In the digital world, securing communication between different systems is paramount. RSA encryption is an asymmetric encryption algorithm and provides a robust way to achieve this by using a pair of keys: one for encryption and one for decryption. On the other hand, symmetric encryption algorithms, such as AES, use a single key for encryption and decryption. For these reasons, asymmetric encryption algorithms may be preferred in order to use the key publicly and avoid problems even if it falls into the hands of an attacker.
+
+In this blog post I will guide you through implementing RSA key generation with OpenSSL, encryption in JavaScript and decryption in .NET, ensuring secure data exchange between a frontend application and a backend service.
+
+## Understanding RSA Encryption
+
+
+RSA (Rivest-Shamir-Adleman) is one of the first public-key cryptosystems and is widely used for secure data transmission. It involves two keys: a public key, which can be shared openly, for encrypting messages, and a private key, must be kept secret, for decrypting them. The strength of RSA lies in the difficulty of factoring the product of two large prime numbers, which underpins its security.
+
+## Generation of Public/Private key pairs with OpenSSL
+
+
+One of the foundational steps in implementing RSA encryption and decryption is the generation of public and private key pairs. OpenSSL, a robust open-source tool for cryptography, offers a straightforward way to generate these keys. However, this step is optional. .NET libraries successfully generate RSA keys. However, using open source tools like this allows us to be ensure of the standards. This section will guide you through the process of generating an RSA public/private key pair using OpenSSL.
+
+We can start with generation of private key as follows:
+
+```bash
+$ openssl genrsa -out privatekey.pem 2048
+
+$ cat privatekey.pem
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDuOitcIPd5UpGN
+/4GEwNhc4fAmGP6fREJJk/byRgiLiWcyXwdoPwXdXjKSjkSIcETdz/hLAlb6+zNY
+Gi4Ap0S5flZSRiKh60xWRA4vZVgsLqhEi2IsclSlWu3R7KD5dkBGsyf5xlCfNSs4
+DbYYMgrXXZxXQ0c4qCikpnEB6OpqSzm19Cwrdq9GwophoAPxnf00d7S+y5QpRa+l
+Ca70xQ42FxBpMuK76a1g6i+JtmPgTYqXZ0FCMnUEzBq+u3N8LKoNzcSNdrLgvmHQ
+oOLFA/9BPe34YgLxoCUi+HhEiLSnvgz/Kn1yprvsz37baYizU/YWFG8s80SPmFsY
+JARxvZiJAgMBAAECggEAEboc42Jln+7Lu34NmIAUKZc7fE5EVjwpVZnP2Lfq510+
+Y2JsZe64pEAf8cVp5qA6E6pn3scKC2uZZr8t+Kj5xXbX/A/RgGyGte2jA5ZeQQ1o
+wo7/q3CHiXVyeHpMATwyLMCkoyLFeY9mi6mDiRniMiP6YAj22gmzWoszIhH/rZCO
+NjdpWRsIkFp8jIiyRhhoaBoJtZ1qV3twk8HH590rgjS7QUGJWK9uUsi5SDh69MsR
+r/SJ00gTMYFozFd6dB29aKj/p8fSk6qzh2noxU37AuiVc1A2H8Z6SAfRUDSvPkxA
+FdqVr62iLWmypBX2VYQ2p1pH1N0v8oG7NTxtrxgRTQKBgQD3YdxKNT0dWZJRGPFC
+DIRZVn86UgDAHRw29aToLARnepE5XOrLSmlGMqbK8vzRyUnlctJyG7x5ure2BMp4
+gKSLuhz48n7ZvpHyCVnNsqqkc21iM/whL/yKiI11Jz5koXmRDltz9IioQH/PwXvD
+RJbjxISHjG5YEKlVmztWtTup/QKBgQD2hqouE8JLePAUzK3SlfgVTlmaHDUeJev4
+u95RWPnMNOOwLUWbGYiKBoJ8uc2nSHmxIvEvEPGNwafR6etf0YocpwDfF5pnPDjk
+yA4hOdZrCyYa/UDqkB5pHTOZj5iVct1hBNbiANz6kL7Pl+H221U+HxD9rhaDPDez
+gdYPhLF4fQKBgQCdi2QomlkufOHS5eiXoLMU1iI2eQzjTGawlaYM+iNf503fU05w
+YxZCT3WroC3kSKXYC1T8uK9CcugWclyje4HPPpq+7GhesZ/unYfkmRlVm/EYbnTu
+icnyS96Ssohou/FYsOULJrt1M4ZyQA1aoS7bJUclsAiB6zJ8Q1z57ndt3QKBgEwa
+9p6S6wBxrWw+Y8sHETdCoNa6rotIGbkIBnIGjddE3KWe1EY1c7lomQ/4LEzgSvEs
+YFivWmLwzeY32LoT7hc6V0KH/tqv9MBsIjCPsmoJXxIl7Mx9AWZh5XQaqHg6pa01
+2UCcE5wm40EjGlcjDwXGgXBPNhP9mxSHmJXh2QfhAoGANouUrF3qv8ofb1HGrUXx
+DO/WkGMzwbkNmwwdgcGYVsGr3Dv/zx1y3TJEvqNh0ViVgmfdYveCo3VrSawq890U
+GJZXld2KFE1icEJpNoURkM9okZMzTDIMs+r4vq5Or2jB04mMuoCbG6rjfqUMtkll
+oAIFOSKH+F3TrXjNgy4/juo=
+-----END PRIVATE KEY-----
+```
+
+After we have successfully created the private key, we can create the public key with the private key we created.
+
+```bash
+$ openssl rsa -in privatekey.pem -outform PEM -pubout -out publickey.pem
+
+$ cat privatekey.pem
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA7jorXCD3eVKRjf+BhMDY
+XOHwJhj+n0RCSZP28kYIi4lnMl8HaD8F3V4yko5EiHBE3c/4SwJW+vszWBouAKdE
+uX5WUkYioetMVkQOL2VYLC6oRItiLHJUpVrt0eyg+XZARrMn+cZQnzUrOA22GDIK
+112cV0NHOKgopKZxAejqaks5tfQsK3avRsKKYaAD8Z39NHe0vsuUKUWvpQmu9MUO
+NhcQaTLiu+mtYOovibZj4E2Kl2dBQjJ1BMwavrtzfCyqDc3EjXay4L5h0KDixQP/
+QT3t+GIC8aAlIvh4RIi0p74M/yp9cqa77M9+22mIs1P2FhRvLPNEj5hbGCQEcb2Y
+iQIDAQAB
+-----END PUBLIC KEY-----
+```
+
+## Setting Up the Environment for .NET RSA Decryption
+
+
+For .NET decryption I will use .NET 8 and use the System.Security.Cryptography namespace. We don’t need any other nuget package for RSA decryption. For RSA Decryption I created a Helper class like this.
+
+We read RsaKey from appsettings.json. You should add \n for newlines in RsaKey field. We put this key in appsettings.json because we want to use same keys in every request. But If you leave it to the responsibility of the .NET library, in every startup there will be newly generated key.
+
+```json
+// appsettings.json
+{
+ "Logging": {
+ "LogLevel": {
+ "Default": "Information",
+ "Microsoft.AspNetCore": "Warning"
+ }
+ },
+ "AllowedHosts": "*",
+ "RsaKey": "-----BEGIN PRIVATE KEY-----\nMIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCuan+y++Eqc2Vx3QIt9gv0r6rzfcxpsBRubcWCmI+8tqb40oflv5dViPSiCSWNgg5xKk7K8WTeEQQ6NDg1IJ2OwoQ2dfzat5qlpfV9EeF3u8iTY/hyQaaYFwB77cV9t5Czb8oG/+IIOByorJVds9tAoKjssKUZ3W9IU7ffElZjZrbjoiy/H4z8u9fOq8IL9Zf3pHgzv2FxF4BPJamqr4s1VtMqGJ5g18wV1OD9gcz9pJOHHUVieZ0+xP4WD4+1wCv/uwEgIcqmEs0os6birHZL1X/CSqBSPc8e/+kkZyyzoF+MBWPzvAwmW32alIxz2ZV0Z+jJtoOrh/qVqbrGAf+RAgMBAAECggEAEWYu4IJHg0ZZOZtgRwj7RtjKXzluraFi3GRHdoB1IFCBRiOsamMrO91qeAqdDCmL+saLbyvXEd8VMqA4djZPeWkWqt8ozwHPY9RzMZuZyCm7t9Zad71sWtI6mmJNF/46qWfOudWHbSX51+rFiMAzMFaGm3wAsFyaaBbv6gkohIhVrrMvpIuV8X8JNI8/VNlOR6vExHd/3uWKi8vPrFEFTNQ1UE+WJDkVojcmx0t63jlP8C/O4ofaJeCYRkAaM9+FXnM+jVNf0qZU+3JGYmy1R/B7L+LyrbG2uYTaBa1Ba9zGsXD1HQ4dctK+MltBd4p+MWgHAQV+xuVmGGDkylpb8QKBgQDP9zY4UzLmnt0werJF9SGmAJU51Y/+gannUC/+XYqnK/NA5iUDR86rlYCJbqQCceyMYJSYuePumygWOVL9rHnu1/fTMG/sXnRktmTSFemgeCYfPyn8/KeZKn6E5xw8GbtfLJLA8uM4DakDf9vSpilKDYT4UbZyKgq7/yodPXbgCQKBgQDWs4gL4yOtDLAY/OQKZvoyXClapldkVFRzf97pBJQGLYfdTzkVFviWsgI/yrA+t5tlzaWtZieuv2KsSmazVyO2W5ei9HILx4yRFK7K56OM5o7wqjN62ZmF0R+422YNaAyqYAd9nhLjgdsrmZ9FTxhQ91asBSH1AO3j6xaZUvh1SQKBgAZuo/ur/xgI89hrAxaM1WSYAgWO6Gw7wHCKF2HrrL0s69InDCAE2YyPDDGz/ViiA2n4FsB+h2E65UuCrGFyMzdC8MRUbDHIXhs7VPT2fopbDPrMblUHz3s6SD1+FG57cUMpUsSq/oIeUgrsqnTidMZ4kpNHm7f+OuTDqJ7M5t9ZAoGAAfm2570YR/BU8nXpNztJVAtLCh17sl2gRUvI5kX3grMKi/u9n7cNZH2Qzbt0sa8Iy///ZUAKX249Xy50EXRczMG8/G/ZWMhmP7N8BDvrYlGAwTAftyKnafbJnu7N2pO5ghvOFdbNf7BjLtyD/aRDqgMMlhqZ/GIczjsMgy6jQJkCgYATxkjdW/mnWLDDZAYm1V10Gnm7YDMwX3gKdhpoYleeeapZiDlurkR3YAEvQezcnhv3NpjaKQtF1/3Q0fZJ0wBc5FflaevHRjHTa0IrU5QIa48dLDx+jxn+cUCFx9kirkb7JcfJLZWtToPMLfCZt324P2ogZgWBwweVPiz1/voEXw==\n-----END PRIVATE KEY-----"
+}
+```
+
+```cs
+// Helpers/RsaEncryptionHelper.cs
+public class RsaEncryptionHelper
+{
+ private readonly RSA _rsa = RSA.Create();
+
+ public RsaEncryptionHelper(IConfiguration configuration)
+ {
+ var privateKeyPem = configuration["RsaKey"];
+ if (string.IsNullOrEmpty(privateKeyPem)) throw new ArgumentNullException(nameof(privateKeyPem));
+ ImportKey(privateKeyPem);
+ }
+
+
+ public void ImportKey(string privateKey)
+ {
+ _rsa.ImportFromPem(privateKey.ToCharArray());
+ }
+
+ public string GetPublicKey()
+ {
+ var publicKey = _rsa.ExportSubjectPublicKeyInfoPem();
+ return publicKey;
+ }
+
+ public string GetPrivateKey()
+ {
+ var privateKey = _rsa.ExportPkcs8PrivateKeyPem();
+ return privateKey;
+ }
+
+ public string Encrypt(string data)
+ {
+ var dataBytes = Encoding.UTF8.GetBytes(data);
+ var encryptedData = _rsa.Encrypt(dataBytes, RSAEncryptionPadding.OaepSHA256);
+ return Convert.ToBase64String(encryptedData);
+ }
+
+ public string Decrypt(string data)
+ {
+ var dataBytes = Convert.FromBase64String(data);
+ var decryptedData = _rsa.Decrypt(dataBytes, RSAEncryptionPadding.OaepSHA256);
+ return Encoding.UTF8.GetString(decryptedData);
+ }
+}
+```
+
+And use this helper class inside of EncryptionController to use helper class’s methods. In production enviroments You should not be expose PrivateKey to anyone. This should be kept secret.
+
+```cs
+// Controllers/EncryptionController.cs
+[ApiController]
+[Route("api/[controller]")]
+public class EncryptionController : ControllerBase
+{
+ private readonly RsaEncryptionHelper _rsaEncryptionHelper;
+
+ public EncryptionController(RsaEncryptionHelper rsaEncryptionHelper)
+ {
+ _rsaEncryptionHelper = rsaEncryptionHelper;
+ }
+
+ [HttpPost("Encrypt")]
+ public string Encrypt([FromBody] EncryptionRequest request)
+ {
+ return _rsaEncryptionHelper.Encrypt(request.Data);
+ }
+
+ [HttpPost("Decrypt")]
+ public string Decrypt([FromBody] EncryptionRequest request)
+ {
+ return _rsaEncryptionHelper.Decrypt(request.Data);
+ }
+
+ [HttpGet("PublicKey")]
+ public string PublicKey()
+ {
+ return _rsaEncryptionHelper.GetPublicKey();
+ }
+
+ [HttpGet("PrivateKey")]
+ public string PrivateKey()
+ {
+ return _rsaEncryptionHelper.GetPrivateKey();
+ }
+
+ [HttpPost("ImportKey")]
+ public void ImportKey([FromBody] ImportKeyRequest request)
+ {
+ _rsaEncryptionHelper.ImportKey(request.PrivateKey);
+ }
+
+}
+
+public record ImportKeyRequest
+{
+ public string PrivateKey { get; init; } = null!;
+}
+
+public record EncryptionRequest
+{
+ public string Data { get; init; } = null!;
+}
+```
+
+After this development we made in the backend side we can continue to JavaScript side. Thanks to all we’ve done we share our public key from endpoint with client, then clients could use this public key to encrypt their data for secure transmission between sides.
+
+## Setting Up the Development environment for JavaScript RSA Encryption
+
+
+Before diving into the code, ensure your environment is set up for JavaScript development. For this example, we’ll use the Web Crypto API, which is built into modern browsers and provides cryptographic operations including RSA encryption. Therefore you don’t need to download any npm packages.
+
+If I am going to develop a browser application with JavaScript, I usually start with Vite. To do this, we can start a project using vanilla js or React by entering the following command. I will develop a small React project for demonstration purposes, but it will be enough even if you stick with vanilla js.
+
+```bash
+npm create vite@latest
+```
+
+After that I will create a src/utils/RsaEncryptionHelper.js file and fill that file as follows. With this file’s methods you can encrypt and decrypt with RSA algorithm but usually decryption is a resposibility of backend side because decryption requires private key and javascript client’s should not be store or access private keys publicly because of security reasons. But I am sharing this in case anyone wants to try something similar to two-way key encryption like in the SSL.
+
+```js
+// src/utils/RsaEncryptionHelper.js
+const encryptAlgorithm = {
+ name: "RSA-OAEP",
+ modulusLength: 2048,
+ publicExponent: new Uint8Array([1, 0, 1]),
+ extractable: true,
+ hash: {
+ name: "SHA-256",
+ },
+};
+
+function arrayBufferToBase64(arrayBuffer) {
+ const byteArray = new Uint8Array(arrayBuffer);
+ let byteString = "";
+ for (let i = 0; i < byteArray.byteLength; i++) {
+ byteString += String.fromCharCode(byteArray[i]);
+ }
+ const b64 = window.btoa(byteString);
+ return b64;
+}
+
+function base64StringToArrayBuffer(b64str) {
+ const byteStr = atob(b64str);
+ const bytes = new Uint8Array(byteStr.length);
+ for (let i = 0; i < byteStr.length; i++) {
+ bytes[i] = byteStr.charCodeAt(i);
+ }
+ return bytes.buffer;
+}
+
+function convertPemToArrayBuffer(pem) {
+ const lines = pem.split("\n");
+ let encoded = "";
+ for (let i = 0; i < lines.length; i++) {
+ if (
+ lines[i].trim().length > 0 &&
+ lines[i].indexOf("-----BEGIN RSA PRIVATE KEY-----") < 0 &&
+ lines[i].indexOf("-----BEGIN PRIVATE KEY-----") < 0 &&
+ lines[i].indexOf("-----BEGIN PUBLIC KEY-----") < 0 &&
+ lines[i].indexOf("-----END RSA PRIVATE KEY-----") < 0 &&
+ lines[i].indexOf("-----END PRIVATE KEY-----") < 0 &&
+ lines[i].indexOf("-----END PUBLIC KEY-----") < 0
+ ) {
+ encoded += lines[i].trim();
+ }
+ }
+ return base64StringToArrayBuffer(encoded);
+}
+
+export const encryptRsa = async (str, pemString) => {
+ try {
+ // convert string into ArrayBuffer
+ const encodedPlaintext = new TextEncoder().encode(str).buffer;
+ const keyArrayBuffer = convertPemToArrayBuffer(pemString);
+ // import public key
+ const secretKey = await crypto.subtle.importKey(
+ "spki",
+ keyArrayBuffer,
+ encryptAlgorithm,
+ true,
+ ["encrypt"]
+ );
+ // encrypt the text with the public key
+ const encrypted = await crypto.subtle.encrypt(
+ {
+ name: "RSA-OAEP",
+ },
+ secretKey,
+ encodedPlaintext
+ );
+ // store data into base64 string
+ return arrayBufferToBase64(encrypted);
+ } catch (error) {
+ console.error("Encryption Error:", error);
+ }
+};
+
+export const decryptRsa = async (str, pemString) => {
+ try {
+ // convert base64 encoded input string into ArrayBuffer
+ const encodedPlaintext = base64StringToArrayBuffer(str);
+ const keyArrayBuffer = convertPemToArrayBuffer(pemString);
+ // import private key
+ const secretKey = await crypto.subtle.importKey(
+ "pkcs8",
+ keyArrayBuffer,
+ encryptAlgorithm,
+ true,
+ ["decrypt"]
+ );
+ // decrypt the text with the public key
+ const decrypted = await crypto.subtle.decrypt(
+ {
+ name: "RSA-OAEP",
+ },
+ secretKey,
+ encodedPlaintext
+ );
+ // decode the decrypted ArrayBuffer output
+ const uint8Array = new Uint8Array(decrypted);
+ const textDecoder = new TextDecoder();
+ const decodedString = textDecoder.decode(uint8Array);
+ return decodedString;
+ } catch (error) {
+ console.error("Decryption Error:", error);
+ }
+};
+```
+
+I developed a small React project using this helper methods. You can use your public and private keys that will be shared from .NET API to encrypt and decrypt data, but keep in mind decryption should be doing in backend side with private key that kept secret.
+
+
+
+
+
+ 
+ 
+ 
+ 
- 
-