ISB VIETNAM CO.,LTD.

While using a computer for work, you'll certainly have to work with licensed applications. One of the important feature of licensed applications is activating the license with a key, but I believe that if you're a first-time user of the application, grasping the activation process can be difficult to ensure the correct execution of the activation process, software developers need to provide detailed and simplified instructions. With a principle of prioritizing user experience and application security, developers often develop the "Auto-Activation" feature, where a single mouse click on the application link automatically activates it and makes it ready to use.

In this article, I will guide you on how to implement the "Auto-Activation" feature via email for a Windows application. There are certainly many other ways to implement this feature, but I will try to provide the simplest instructions possible so that you can understand how this feature works and apply it to your project.

1. Development environment

For implementing the auto-activation feature via email for a Windows application, I will develop an environment with two main components:

- ActivationServer:
  - Function: Manage data, send emails, redirect activation links
  - Email service: Gmail
  - Web Framework: ASP.NET
- Application:
  - Function: Perform activation
  - Application Framework: Windows Form C#

2. Functional design

Regarding the specific operation of the feature, I will describe it according to the diagram below. Through the Windows operating system allowing you to call commands to open applications via "application protocol" (reference "Registering an Application to a URI Scheme"), we will create an application protocol for our application. Then, we can pass the activation key to the application to activate it as a URI parameter.

Picture 1. Auto activation email sending sequence diagram

Picture 2. Auto activation processing sequence diagram

3. Functional development

On the server side, I will implement the routes as follows:

- GET Home/index: Display the email sending form.
- POST Home/SendMail: Generate the activation key and send the email.
- GET Home/AutoRedirect: Perform redirection to the application protocol.

HomeController.cs

using System;
using System.Net;
using System.Net.Mail;
using System.Web.Mvc;
using Utility;

namespace ActivationServer.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            return View("Index", new ViewDataDictionary { { "message", string.Empty } });
        }

        [HttpPost]
        public ActionResult SendMail(FormCollection form)
        {
            try
            {
                string emailAddress = form["email"];
                string host = "http://myserver.com";
                string mailAddress = "myemail@gmail.com";
                string mailPassword = "mypassword";
                string mailHost = "smtp.gmail.com";
                int maiPort = 587;
                string mailSubject = "Auto activation email";
                string mailBody = "<h2>Auto Activation Email</h2><a href="{{ActivationLink}}">Click here to active!</a>";
                mailBody = mailBody.Replace("{{ActivationLink}}",
                           $"{host}/Home/AutoRedirect?protocol=appdemo&param=myactivationkey}");

                using (SmtpClient client = new SmtpClient())
                {
                    client.Host = mailHost;
                    client.Port = maiPort;
                    client.EnableSsl = true;
                    client.Credentials = new NetworkCredential(mailAddress, mailPassword);

                    using (MailMessage message = new MailMessage())
                    {
                        message.From = new MailAddress(mailAddress);
                        message.To.Add(new MailAddress($"{emailAddress}"));
                        message.Subject = mailSubject;
                        message.Body = mailBody;
                        message.IsBodyHtml = true;

                        client.Send(message);
                    };
                };
                return View("Index", new ViewDataDictionary { { "message", "Activation mail has been sent!" } });
            }
            catch (Exception ex)
            {
                return View("Error", new ViewDataDictionary { { "message", ex.Message } });
            }
        }

        public ActionResult AutoRedirect(string protocol, string param)
        {
            return Redirect($"{protocol}://?key={param}");
        }
    }
}

In the example, I'm using email sending with an HTML code to embed a link in the email using an <a> tag.

I'll further explain why we don't directly insert the application protocol into the activation link. The reason is that an application protocol inherently lacks the format of an HTML protocol, making it prone to being stripped out by email servers during the email sending process. Therefore, instead of directly inserting the application protocol, we'll use a route like "Home/AutoRedirect" to redirect to the application protocol.

Index.cshtml

@{
    ViewBag.Title = "Home Page";
}

<main>
    <section class="row" aria-labelledby="aspnetTitle">
        <h1 id="title">Auto Activation Demo</h1>
    </section>

    <div class="row">
        <section class="col-md-4" aria-labelledby="">
            <form method="post" action="@Url.Action("SendMail")">
                <div class="mb-3">
                    <label for="txtEmail" class="form-label">Email address</label>
                    <input type="email" class="form-control" name="email" id="txtEmail" required>
                </div>
                <button type="submit" class="btn btn-primary">Submit</button>
            </form>
        </section>

        <section class="row mt-3">
            <p id="message">@Model["message"]</p>
        </section>
    </div>
</main>

On the application side, I will implement 2 forms as follows:

- Active: Activation screen

Picture 3. Active Screen

- Main: Main screen of the application

Picture 4 . Main Screen

I'll add modifications so that the application can be launched via CLI with a "key" parameter. This is aimed at inserting the activation key into the activation screen upon startup.

Programs.cs

using System.Web;
using Utility;
using AppSetting = ApplicationDemo.Properties.Settings;

namespace ApplicationDemo
{
    internal static class Program
    {
        private static Mutex? mutex = null;

        ///
        ///  The main entry point for the application.
        /// 
        [STAThread]
        static void Main()
        {
            const string appName = "ApplicationDemo";
            bool createdNew;

            mutex = new Mutex(true, appName, out createdNew);

            if (!createdNew)
            {
                MessageBox.Show("Application already running!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            ApplicationConfiguration.Initialize();

            Form startForm = new Main();
            if (string.IsNullOrWhiteSpace(AppSetting.Default.Key) || !CommonCode.IsValidKey(AppSetting.Default.Key))
            {
                string[] args = Environment.GetCommandLineArgs();
                string key = string.Empty;
                if (args.Length > 1)
                {
                    Uri uri = new Uri(args[1]);
                    key = $"{HttpUtility.ParseQueryString(uri.Query).Get("key")}";
                }
                startForm = new Active(key);
            }

            Application.Run(startForm);
        }
    }
}

Active.cs

using Utility;
using AppSetting = ApplicationDemo.Properties.Settings;

namespace ApplicationDemo
{
    public partial class Active : Form
    {
        public Active(string key)
        {
            InitializeComponent();

            txtActivationKey.Text = key;
        }

        private void btnActive_Click(object sender, EventArgs e)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(txtActivationKey.Text))
                {
                    throw new Exception("Please enter activation key!");
                }

                if (CommonCode.IsValidKey(txtActivationKey.Text))
                {
                    MessageBox.Show("Activation Successful", "Information", MessageBoxButtons.OK,
                                    MessageBoxIcon.Information);
                    AppSetting.Default.Key = txtActivationKey.Text;
                    AppSetting.Default.Save();
                    Main main = new();
                    main.Show();
                    Hide();
                }
                else
                {
                    MessageBox.Show("The activation key is invalid!", "Error", MessageBoxButtons.OK,
                                     MessageBoxIcon.Warning);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }

        private void Active_FormClosed(object sender, FormClosedEventArgs e)
        {
            Application.Exit();
        }

        private void Active_Shown(object sender, EventArgs e)
        {

            if (!string.IsNullOrWhiteSpace(txtActivationKey.Text))
            {
                btnActive.PerformClick();
            }
        }
    }
}

Main.cs

using AppSetting = ApplicationDemo.Properties.Settings;

namespace ApplicationDemo
{
    public partial class Main : Form
    {
        public Main()
        {
            InitializeComponent();
        }

        private void btnDeactive_Click(object sender, EventArgs e)
        {
            AppSetting.Default.Key = string.Empty;
            AppSetting.Default.Save();

            Active active = new Active(string.Empty);
            active.Show();
            Hide();
        }

        private void Main_FormClosed(object sender, FormClosedEventArgs e)
        {
            Application.Exit();
        }
    }
}

To make the application operational with an application protocol, we'll register it through the registry as follows, with the "ExecFilePath" is the location where the application is installed.

AppDemo.reg

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\appdemo]
"URL Protocol"=""
@="URL:appdemo"

[HKEY_CLASSES_ROOT\appdemo\shell]

[HKEY_CLASSES_ROOT\appdemo\shell\open]

[HKEY_CLASSES_ROOT\appdemo\shell\open\command]
@="ExecFilePath"   \"%1\""

To perform registry registration during application setup, you'll need to use a third-party software to package the application.

4. Operational demo:

5. Advantages and disadvantages:

- Advantages:
  - User Experience: Streamlined activation process enhances user experience, reducing user frustration and increasing satisfaction.
  - Automation: Automating the activation process saves time and effort for both users and administrators.
  - Security: By encrypting the activation key and embedding it in a link, security is enhanced compared to manual entry or transmission via insecure channels.
  - Ease of Use: One-click activation simplifies the process for users, especially for those who may not be technically savvy.
- Disadvantages:
  - Complexity of Implementation: Setting up the infrastructure for automated activation, including server-side processing and email integration, can be complex and require additional development effort.
  - Compatibility Issues: Because the information of the application protocol needs to be registered with the exact path to the application to be opened, it will not work if the user moves the application to a different directory.

Cover image from freepik.com

Reference:

TECH

December 7, 2024

CakePHP 4: How to implement authorization.

In the previous sections, I introduced how to create a login feature for a website developed based on the CakePHP framework.

CakePHP 4: How to Create a Login Function.

CakePHP 4: How to Create a Token-Based Login Function.

In this article, I introduce how to implement authorization in an application using the CakePHP framework by utilizing the Authorization plugin.

1, Installation

We install the plugin with composer using the command below:
php composer.phar require "cakephp/authorization:^2.0"
The Authorization plugin integrates with the CakePHP application as both a middleware layer and a component to easily check authorization. In src/Application.php, implement the AuthorizationServiceProviderInterface interface and implement the getAuthorizationService() function as shown below.

class Application extends BaseApplication implements AuthenticationServiceProviderInterface, AuthorizationServiceProviderInterface
{
    /**
    * getAuthenticationService
    * @param ServerRequestInterface $request
    */
   public function getAuthorizationService(ServerRequestInterface $request): AuthorizationServiceInterface
   {
       $resolver = new OrmResolver();
       return new AuthorizationService($resolver);
   }
}

In the bootstrap() function, add the plugin as shown below:

/**
* Load all the application configuration and bootstrap logic.
*
* @return void
*/
public function bootstrap(): void
{
// Call parent to load bootstrap from files.
parent::bootstrap();

// …

// Load more plugins here
$this->addPlugin('Authentication');
$this->addPlugin('Authorization');
}

In the middleware() function, add the AuthorizationMiddleware.

/**
* Setup the middleware queue your application will use.
*
* @param \Cake\Http\MiddlewareQueue $middlewareQueue The middleware queue to setup.
* @return \Cake\Http\MiddlewareQueue The updated middleware queue.
*/
public function middleware(MiddlewareQueue $middlewareQueue): MiddlewareQueue
{
$middlewareQueue
// …
->add(new BodyParserMiddleware())

->add(new AuthenticationMiddleware($this))
->add(new AuthorizationMiddleware($this));

return $middlewareQueue;
}

In src/Controller/AppController.php, load the Authorization component in the initialize() function.

class AppController extends Controller
{
/**
* Initialization hook method.
*
* Use this method to add common initialization code like loading components.
*
* e.g. `$this->loadComponent('FormProtection');`
*
* @return void
*/
public function initialize(): void
{
parent::initialize();
// …

$this->loadComponent('Authentication.Authentication');
$this->loadComponent('Authorization.Authorization', [
'skipAuthorization' => [
'login','webLogin', 'logout' // functions do not need to check authorization.
]
]);
}
}

2, Policies.

Policies are classes that resolve permissions for a given object. These classes will be stored in the src/Policy directory. We can generate a policy class for an entity or table using CakePHP's bake.

# Create an entity policy
bin/cake bake policy --type entity Article

# Create a table policy
bin/cake bake policy --type table Articles

3, Implement.

In this article, I will implement API authorization requirements in the table below using policy.

Title	endpoints	remark
Update an Article (PUT)	/api/articles/{id}.json	Can only be used by authenticated article writer users.
See like count on an article(GET)	/api/articles/{article_id}/likes.json	All users can see like count on an article.

For the API Update an Article (PUT), can only be used by authenticated article writer users. We check if the logged-in user is the owner of the article to determine the edit permissions.

class ArticlePolicy
{
// …

/**
* Check if $user can edit Article
*
* @param \Authorization\IdentityInterface $user The user.
* @param \App\Model\Entity\Article $article
* @return bool
*/
public function canEdit(IdentityInterface $user, Article $article): Result
{
$isAuthor = $this->isAuthor($user, $article);
if ($isAuthor) {
return new Result(true);
}
return new Result(false, 'Permission denied');
}

protected function isAuthor(IdentityInterface $user, Article $article)
{
return $user->getIdentifier() === $article->user_id;
}

}

For the API See like count on an article(GET), all users can see like count on an article. In the LikePolicy class, the canView() function returns true so that all users can see the number of likes on the article.

/**
* Likes policy
*/
class LikesPolicy
{
/**
* Check if $user can view Likes
*
* @param \Authorization\IdentityInterface $user The user.
* @param \App\Model\Entity\Likes $likes
* @return bool
*/
public function canView(IdentityInterface $user, Likes $likes)
{
return true;
}
}

4, Testing.

For the API Update an Article (PUT), update the article with the user as the owner.

For the API Update an Article (PUT), update the article with a user who is not the owner. The expected result is that the article will not be updated.

For the API See like count on an article(GET), check with a user who is not logged in.

For the API See like count on an article(GET), check with a logged-in user who is not the owner.

You can find the complete source code at: https://github.com/ivc-phampbt/cakephp-authentication

Conclusion

I hope this article helps you understand how CakePHP integrates with the Authorization plugin to implement authorization and can be applied to projects related to CakePHP.

References

https://book.cakephp.org/authorization/2/en/index.html

https://www.rockersinfo.com/php-frameworks/cakephp-development-company/ [Image]

Ranking	Programming Language	Ratings
1	Python	23.84%
2	C++	10.82%
3	Java	9.72%
4	C	9.10%
5	C#	4.87%
6	JavaScript	4.61%
7	Go	2.17%
8	SQL	1.99%
9	Visual Basic	1.96%
10	Fortran	1.79%
11	Delphi/Object Pascal	1.44%
12	PHP	1.39%
13	Scratch	1.33%
14	Rust	1.29%
15	MATLAB	1.09%
16	R	1.05%
17	Assembly language	1.04%
18	Ruby	1.03%
19	COBOL	0.98%
20	Swift	0.98%
21	Lisp	0.97%
22	Prolog	0.90%
23	Kotlin	0.82%
24	Ada	0.72%
25	Classic Visual Basic	0.70%
26	Perl	0.64%
27	Lua	0.64%
28	SAS	0.57%
29	(Visual) FoxPro	0.57%
30	Haskell	0.54%
31	Scala	0.51%
32	Julia	0.50%
33	Dart	0.47%
34	VBScript	0.41%
35	Objective-C	0.38%
36	Transact-SQL	0.37%
37	PowerShell	0.37%
38	Bash	0.33%
39	PL/SQL	0.27%
40	D	0.21%
41	Solidity	0.20%
42	TypeScript	0.20%
43	GAMS	0.20%
44	ABAP	0.19%
45	Awk	0.17%
46	X++	0.16%
47	RPG	0.15%
48	Elixir	0.15%
49	ML	0.14%
50	Clojure	0.14%

Programming Language	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec
Python	13.97%	15.16%	15.63%	16.41%	16.33%	15.39%	16.12%	18.04%	20.17%	21.90%	22.85%	23.84%
C++	9.96%	10.53%	10.70%	9.76%	9.53%	10.03%	10.34%	10.04%	10.75%	11.60%	10.64%	10.82%
Java	7.87%	8.88%	8.95%	8.94%	8.69%	8.40%	8.59%	9.16%	9.45%	10.51%	9.60%	9.72%
C	11.44%	10.97%	11.17%	10.21%	9.98%	9.23%	9.48%	9.17%	8.89%	8.38%	9.01%	9.10%
C#	7.16%	7.53%	7.54%	6.77%	6.49%	6.65%	6.72%	6.39%	6.08%	5.62%	4.98%	4.87%
JavaScript	2.77%	3.17%	3.38%	2.89%	3.01%	3.32%	3.79%	3.91%	3.92%	3.54%	3.71%	4.61%
Go	1.38%	1.73%	1.56%	1.85%	1.60%	1.93%	2.19%	2.03%	2.35%	2.02%	2.35%	2.17%
SQL	1.46%	1.82%	1.92%	1.61%	1.44%	1.75%	2.04%	2.21%	1.94%	1.64%	1.94%	1.99%
Visual Basic	1.60%	1.52%	1.42%	1.70%	2.01%	1.66%	2.08%	2.18%	2.70%	2.35%	1.95%	1.96%
Fortran	1.09%	1.40%	1.22%	1.47%	1.24%	1.53%	2.05%	1.79%	1.78%	1.80%	1.97%	1.79%

Feature	SOAP	REST
Protocol vs. Style	SOAP is a protocol with strict rules	REST is an architectural style, not a protocol
Data Format	XML	Typically JSON (but can also be XML)
Security	Built-in security (WS-Security)	Relies on HTTPS for security
Error Handling	Detailed error handling with <fault> element	Custom error messages via HTTP status codes
Performance	Slower due to XML overhead	Faster and more efficient with JSON
Stateful/Stateless	Can be stateful or stateless	Stateless by design
Ease of Use	More complex and harder to implement	Simpler to implement and easier to use
Use Case	Enterprise systems, financial transactions, healthcare	Web and mobile applications, lightweight services

How to implement automatic activation feature for Windows applications.

Leave a comment cancel

How to implement automatic activation feature for Windows applications.

Leave a comment cancel

Most popular programming languages in 2024

The TIOBE Index

How the TIOBE Index Is Defined

2024 Programming Language Popularity Ranking

2024 Programming Language Popularity Ranking TOP50

2024 Monthly Trends in Programming Language Popularity

Python: Dominating AI & Data Science

C++, Java, and C: Evolving Foundations

C# and JavaScript: Specialized Ecosystems and Mixed Fortunes

Conclusion

About ISB VIETNAM

CakePHP 4: How to implement authorization.

1, Installation

2, Policies.

3, Implement.

4, Testing.

Conclusion

References

Introduction About SOAP API