How can you add security to existing objects without changing their code?

由人工智能和领英社区提供技术支持

Security is a crucial aspect of any software system, especially when dealing with sensitive data or transactions. However, sometimes you may need to add security features to existing objects without modifying their original code. How can you do that without breaking the existing functionality or introducing new bugs? In this article, you will learn how to use design patterns to achieve this goal.

此文章中的业界达人

由社区从 8 条内容中精选。了解更多

Amritpal Singh

CTO at Zapbuild Technologies
Susmit Tyagi

Architect | 5 x Community Top Voice | Togaf Certified
Tulip Agarwal

Senior Principal Software Engineer at UKG (Ultimate Kronos Group)

1 Decorator Pattern

One way to add security to existing objects is to use the decorator pattern. This pattern allows you to attach additional responsibilities to an object dynamically, without changing its interface or subclassing it. For example, you can create a security decorator that wraps an existing object and adds authentication, encryption, or logging features to its methods. The security decorator can either delegate the calls to the original object after performing the security checks, or reject them if they fail. The advantage of this approach is that you can apply the security decorator to any object that implements the same interface, without changing its code or affecting other decorators.

添加您的观点

Amritpal Singh

CTO at Zapbuild Technologies
举报内容
interface IService { string GetMessage(); } clas Service1 : IService { override string GetMessage() => "Service1"; } abstract class SecurityDecorator:IService { IService _service; void SecurityDecorator(IService serv) { _serivce = serv; } string GetMessage() => _service.GetMessage(); } class AESSecurityEnc : SecurityDecorator { void AESSecuityEnc(IService serv):base(serv) {} string GetMessage() => EncryptAES(base.GetMessage()); } class RSASecurityEnc : SecurityDecorator { void RSASecuityEnc(IService serv):base(serv) {} string GetMessage() => EncryptRSA(base.GetMessage()); } class main() { var service = new RSASecurityEnc(new Service1()); }

已翻译

赞
Tulip Agarwal

Senior Principal Software Engineer at UKG (Ultimate Kronos Group)
举报内容
Decorator pattern is useful in cases where we delegate to an async process and still needs the authentication context of the invoker thread. While invoking the target object is wrapped with an instance of decorator class and in the constructor the authentication context of the calling thread is stored. Then when the target object is called it will use the authentication context that was saved during the creation.

已翻译

赞

2 Proxy Pattern

Another way to add security to existing objects is to use the proxy pattern. This pattern provides a surrogate or placeholder for another object, controlling access to it. For example, you can create a security proxy that acts as an intermediary between a client and a server object, and performs security checks before forwarding the requests or returning the responses. The security proxy can also cache, filter, or modify the data as needed. The advantage of this approach is that you can isolate the security logic from the business logic, and protect the server object from unauthorized or malicious access.

添加您的观点

Amritpal Singh

CTO at Zapbuild Technologies
举报内容
interface IInternetAccess { public ConnectToInternet(string hostName); } class RawInternetAccess:IInternetAccess { public ConnectToInternet(string hostName) { //Code to Connect to Internet } } class ProxyInternetAccess:IInternetAccess { List<string> bannedHostNames = {"site1", "site2", "site3"}; IInternetAccess objInternetAccess = new RawInternetAccess(); public ConnectToInternet(string hostName) { if(!bannedHostNames.Contains(hostName) objInternetAccess .ConnectToInternet(hostName); else Alert("Banned"); } }

已翻译

赞
Tulip Agarwal

Senior Principal Software Engineer at UKG (Ultimate Kronos Group)
举报内容
Spring framework relies heavily on proxy patterns for providing flexible transaction and app support. Proxy patterns when used efficiently can prove very effective in achieving separation of concerns.

已翻译

赞

3 Adapter Pattern

A third way to add security to existing objects is to use the adapter pattern. This pattern allows you to adapt an existing object to a different interface, making it compatible with another object or system. For example, you can create a security adapter that converts the input and output data formats between a legacy object and a modern security system, such as JSON and OAuth. The security adapter can also handle encryption, decryption, or validation of the data as needed. The advantage of this approach is that you can reuse an existing object without changing its code or exposing its details to the security system.

添加您的观点

Susmit Tyagi

Architect | 5 x Community Top Voice | Togaf Certified
(已编辑)
举报内容
A security adapter is required when transitioning from a legacy Auth service (Database, LDAP) to a modern Auth service (OAuth) . Few steps to get this working - Define the target interface - Adaptee i.e. the new Auth Service is to be developed and can have an incompatible interface - Adapter implements the target interface and translate calls to the new service Auth Service - Integrate the adapter into the application using the new Authn Service .

已翻译

赞

4 Strategy Pattern

A fourth way to add security to existing objects is to use the strategy pattern. This pattern allows you to define a family of algorithms, encapsulate them in separate classes, and make them interchangeable at runtime. For example, you can create a security strategy that defines an interface for performing security operations, such as hashing, signing, or verifying. Then, you can implement different classes that conform to this interface, using different algorithms, such as SHA-256, RSA, or HMAC. Finally, you can assign a security strategy object to an existing object, and use it to perform the security operations on its data. The advantage of this approach is that you can vary the security behavior of an existing object without changing its code or affecting other objects.

添加您的观点

Susmit Tyagi

Architect | 5 x Community Top Voice | Togaf Certified
举报内容
The Strategy pattern allows for the implementation of a chosen authentication method at runtime. To achieve this: Define a strategy interface, such as AuthenticationStrategy. Create concrete classes that implement this interface, representing different authentication methods like Legacy, OAuth, and 2FA. Develop an AuthenticationContext that injects the appropriate authentication strategy at runtime to perform authentication

已翻译

赞
Eugene H.

Entrepreneurship, Technology & Innovation
举报内容
This is one of the most versatile flexible patterns. IMO, many patterns are built with this as a base. It employs polymorphism and executes a security strategy at run-time without changing the code!

已翻译

赞

5 Facade Pattern

A fifth way to add security to existing objects is to use the facade pattern. This pattern provides a simplified interface to a complex system or subsystem, hiding its details and complexity. For example, you can create a security facade that exposes a simple and consistent interface for performing security tasks, such as generating keys, encrypting data, or authenticating users. The security facade can then delegate the calls to the appropriate objects or classes within the security system or subsystem, such as key generators, cipher engines, or authenticators. The advantage of this approach is that you can simplify the security interactions for the existing objects, and reduce the coupling and dependencies between them and the security system or subsystem.

添加您的观点

Susmit Tyagi

Architect | 5 x Community Top Voice | Togaf Certified
(已编辑)
举报内容
An Authentication pattern called "Auth Facade" or "Identity Broker" is popular when application is deployed on premise in heterogeneous environments. Few applications are still deployed On Premise due to Data Gravity, Security and availability reasons . Here different enterprise Identity Providers can be used relying on OIDC (OP) or SAML (IdP) . Instead of directly providing integrations with these providers and standards we can use the Auth Facade/Identity Broker . The Auth Facade hides the subsystem the clients Identity Provider. The client sends authentication requests to this facade and it in turn federates as needed with the upstream Identity providers .

已翻译

赞

6 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?

添加您的观点

Design Patterns

+ 关注

给文章评分

我们借助人工智能创建了此文章。您认为这篇文章怎么样？

很棒不太好

举报此文章

查看全部

How can you add security to existing objects without changing their code?

1

2

3

4

5

6

1 Decorator Pattern

2 Proxy Pattern

3 Adapter Pattern

4 Strategy Pattern

5 Facade Pattern

6 Here’s what else to consider

Design Patterns

给文章评分

感谢您的反馈

更多Design Patterns相关文章

更多相关阅读内容