C-Cubed

ccubed

A key technique in image editing applications is determining the dominant colors. The identification of these dominant colors is essential for creating an image's palette, which, in turn, accurately reflects the effect of selected tools and the results of editing. This article will delve into how to determine an image's palette within a restricted color space, identify an image's dominant colors, and differentiate between a palette and dominant colors. Palette The image palette is typically a reference to all the colors present in the original image. In essence, it captures the entire range of color shades, based on the numerical scale of color stimulus signal values. If we agree on modeling a signal with a certain level of accuracy, then the range of these signal values will represent our available color palette. Each unique representation of an image and the mapping of an image's colors onto this space will be a subset of it. In digital signal processing (an image is also a signal), we often understand a variety of quantities through its discrete representation. Thus, our image palette can be viewed as a subset of all the colors in the image represented by a discrete map. Each color can be indexed and assigned a specific value in one of the color spaces. For our purposes, we'll use the RGB color model. A significant challenge in presenting the image palette in this way is the vastness of human visibility. It's unlikely we can manually analyze the entire image palette, and it often doesn't make sense to store an image represented by all the original colors. Instead, we reduce their number to a reasonable limit. This process, known as color quantization, involves lowering the number of colors from the full subset that can be represented in an image to a smaller one. For instance, 14-bit raw color data might be represented in 8-bit JPEG or 16-bit TIFF converted to 8-bit PNG. A straightforward solution to determine an image's primary colors is to envision the process of color quantization to a very limited set, such as 8 or even 3 colors. This gives us insight into the primary colors within the image, making them more noticeable and memorable. Ideally, the colors in the final image should be harmonious, following the principles outlined by or . Johannes Itten Matyushin By identifying the dominant colors of an image, we can create a tool that allows us to visualize the image's "harmony." This can also apply to the harmony of the image after filtering, or "synthetic harmonization." Below, we will make an attempt to develop such a tool. Median Cut A widely used and high-quality algorithm for compressing an image's palette is the Median Cut algorithm. It's incorporated into most major lossy image compression algorithms, such as JPEG, albeit with some modifications. The fundamental principle of the Median Cut algorithm is to sequentially divide the image's cubic histogram into medians. Each resulting subcube contains approximately an equal number of bins, or pixels of the same color. Once the division process reaches a predetermined number of subcubes, we calculate the average color of each cube and map it to the corresponding colors of the original image. This process effectively reduces the number of colors in the original image, allowing us to compress the image into a smaller file size. It might seem at first glance that the initial part of this algorithm could solve our problem of identifying the primary or dominant colors of an image. However, a potential issue arises when the number of colors into which we divide the image is too few, and we're only analyzing a small number of colors. We might end up identifying colors that don't actually exist in the image because the colors are excessively averaged. We could choose the color with the maximum bin from each cube and label it as dominant, but then it wouldn't constitute a palette anymore. So, we'll reserve this approach for determining of the image's palette, which can also be used as a tool for visually analyzing the image in terms of its "harmonious utility." To identify the dominant colors, we'll employ statistical analysis: searching for local maxima in the same cubic histogram. a compressed version Local Maxima To identify the local maxima, we will implement a specific code. The author, who is also a skilled artist, provides an excellent description of the algorithm. Essentially, we first gather the image statistics into the same three-dimensional RGB histogram used in the Median Cut algorithm. Each cell of the cubic histogram will contain color bins, and the sum of all values of each color included in the cell. Given the limited histogram dimension to a resolution of 32x32x32 (originally 30x30x30), accumulating the sum simplifies the calculation of the average cell color. We then search for the local maximum by thoroughly exploring the entire space and comparing it with neighboring cells. Following this, we iteratively reduce the number of local maxima to the required amount, discarding similar colors with less weight. For all remaining local maxima, we calculate the average colors of all values included in the list. Since the color density in local maxima is higher, and the difference between pixel values is smaller than in cubes from the Median Cut, the colors will be more akin to those present in the main image and will more accurately represent its dominant colors. This reveals the primary difference between the two models: acquiring a versus searching for local maxima or . By mapping the primary "compressed palette" image, we will create a new one , albeit in a vastly truncated form. "compressed palette" dominant colors that maintains the same color balance as the main image On the other hand, dominant colors . They cannot be transformed into anything new with a suitable color balance. only describe the composition of the colors primarily present in the image Implementation Using this task as an example, we will demonstrate how straightforward it is to develop a ready-to-use application for image analysis and manipulation using the . We will begin with functionalities that are absent in other engines. IMProcessing Framework For instance, the framework has the capacity to read Adobe files with pre-existing CLUTs and can extract a three-dimensional cubic histogram from an image in real-time. .cube Capitalizing on this, we aim to create an application that can: Upload files in JFIF (jpeg) format. “Normalize” the original image. Control the intensity of the “normalizer.” Incorporate an arbitrary LUT from an Adobe .cube file into the processing. Manage the intensity of CLUT's impact. Display a linear histogram of the image. Exhibit the “compressed palette” and dominant colors of the image as well as their numerical representation in the form of a triplet (r,g,b) The end product of our construction will resemble this interactive toy: Here, it's clear how the image's simple “normalization” positively influences the diversity of the final palette, re-distributing dominant colors into a more varied and harmonious set. "Normalizer" We will assemble a filter from two pre-existing ones: - allows the stretching of the image histogram to specified boundaries IMPContrastFilter - performs automatic white balance correction based on the search for the average color and the correction of spurious tones in the image. This is essentially a slight modification of an idea borrowed from IMPAutoWBFilter . Andrey Zhuravlev’s blog import IMProcessing
 
/// Image filter
public class IMPTestFilter:IMPFilter {
 
    /// We will use a contrast control filter through histogram stretching
    var contrastFilter:IMPContrastFilter!
 
    /// Auto white balance filter
    var awbFilter:IMPAutoWBFilter!
 
    /// Image Linear Histogram Analyzer
    var sourceAnalyzer:IMPHistogramAnalyzer!
 
    /// Solver of the histogram analyzer for calculating the lightness boundaries of the image
    let rangeSolver = IMPHistogramRangeSolver()
 
    public required init(context: IMPContext) {
        super.init(context: context)
 
        //  Initialize filters in context
        contrastFilter = IMPContrastFilter(context: context)
        awbFilter = IMPAutoWBFilter(context: context)
 
        // Add filters to the stack
        addFilter(contrastFilter)
        addFilter(awbFilter)
 
        // Initialize the histogram analyzer
        sourceAnalyzer = IMPHistogramAnalyzer(context: self.context)
 
        // Add a light boundary search solver to the analyzer
        sourceAnalyzer.addSolver(rangeSolver)
 
        // Add an observing handler to the filter for
        // to pass the current image frame to the analyzer
        addSourceObserver { (source) - Void in
            self.sourceAnalyzer.source = source
        }
 
        // Add an observing handler for updating analysis calculations to the analyzer
        sourceAnalyzer.addUpdateObserver({ (histogram) - Void in
        // set the lightness boundaries in the contrast filter each time the image changes
            self.contrastFilter.adjustment.minimum = self.rangeSolver.minimum
            self.contrastFilter.adjustment.maximum = self.rangeSolver.maximum
        })
 
    }
} Palette Solver The IMProcessing Framework stands out from many similar platforms due to its unique organization of calculations. It uses a dedicated group of filters that essentially are not processing filters. The objects of these classes do not modify the image in the homogeneous and spatial domains. Instead, they perform certain calculations and representations of metrics for analysis in special expanders to solve specific problems. For instance, an object of the IMPHistogramAnalyzer class can simultaneously add multiple solvers that calculate the average color of the image, the light range, zonal division, etc. We use the solver to extend the analysis of IMPHistogramCubeAnalyzer to calculate the palette and the list of dominant colors. The calculation results are then displayed in an updated NSTableView. import IMProcessing
 
///  Types of distribution of image color accents
///
///  - palette:   palette for quantizing image colors.
///               calculated using the median-cut transformation scheme:
///               http://www.leptonica.com/papers/mediancut.pdf
///  - dominants: calculation of dominant colors of an image by searching for local maxima
///               color distribution density functions:
///               https://github.com/pixelogik/ColorCube
///
public enum IMPPaletteType{
    case palette
    case dominants
}
 
/// Solver of the cubic color histogram analyzer IMPHistogramCubeAnalyzer
public class IMPPaletteSolver: IMPHistogramCubeSolver {
 
    /// Maximum number of palette colors for analysis
    public var maxColors = Int(8)
 
    /// List of found colors
    public var colors = [IMPColor]()
 
    /// Palette type
    public var type = IMPPaletteType.dominants
 
	  /// Solver handler handler
    /// - parameter analyzer: link to the analyzer
    /// - parameter histogram: cubic histogram of the image
    /// - parameter imageSize: image size
    public func analizerDidUpdate(analizer: IMPHistogramCubeAnalyzer, histogram: IMPHistogramCube, imageSize: CGSize) {
 
        var p = [float3]()
        if type == .palette{
            p = histogram.cube.palette(count: maxColors)
        }
        else if type == .dominants {
            p = histogram.cube.dominantColors(count: maxColors)
        }
 
        colors.removeAll()
 
        for c in p {
            colors.append(IMPColor(color: float4(rgb: c, a: 1)))
        }
    }
} We Assemble All the Components in the View Controller The controller will need the main application filter, which we'll call , a CLUT filter named IMPLutFilter, the ready-to-use IMPHistogramView for displaying a "regular" histogram, the IMPHistogramCubeAnalyzer which is a cubic histogram analyzer to which we will attach our solver, the IMPPaletteSolver. IMPTestFilter Lastly, we'll use IMPImageView as the main window for displaying the image, and the common IMPContext is the key class used by all constructors of the framework. class ViewController: NSViewController {
 
    //
    // Processing context
    //
    let context = IMPContext()
    //
    // Window for presenting the loaded image
    //
    var imageView:IMPImageView!
 
    var pannelScrollView = NSScrollView()
 
    //
    // Window for displaying the image histogram
    //
    var histogramView:IMPHistogramView!
 
    //
    // NSTableView - views of a list of colors from the palette
    //
    var paletteView:IMPPaletteListView!
 
    //
    // Main filter
    //
    var filter:IMPTestFilter!
 
    //
    // CLUT filter from Adobe Cube files
    //
    var lutFilter:IMPLutFilter?
 
    //
    // Analyzer of a cubic histogram of an image in RGB space
    //
    var histograCube:IMPHistogramCubeAnalyzer!
 
    //
    // Our solver for finding colors
    //
    var paletteSolver = IMPPaletteSolver()
 
    var paletteTypeChooser:NSSegmentedControl!
 
    override func viewDidLoad() {
 
        super.viewDidLoad()
 
        configurePannel()
 
        //
        // Initialize the objects we need
        //
 
        filter = IMPTestFilter(context: context)
 
        histograCube = IMPHistogramCubeAnalyzer(context: context)
        histograCube.addSolver(paletteSolver)
 
        imageView = IMPImageView(context: context, frame: view.bounds)
        imageView.filter = filter
        imageView.backgroundColor = IMPColor(color: IMPPrefs.colors.background)
 
        //
        // Add another handler to monitor the original image
        // (another one was added in the main filter IMPTestFilter)
        //
        filter.addSourceObserver { (source) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
            //
            // to minimize calculations, the analyzer will compress the image to 1000px on the wide side
            //
            if let size = source.texture?.size {
                let scale = 1000/max(size.width,size.height)
                self.histograCube.downScaleFactor = scale.float
            }
        }
 
        // Add an observer to the filter to process the filtering results
        //
        filter.addDestinationObserver { (destination) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
 
            // pass the image to the histogram indicator
            self.histogramView.source = destination
 
            // pass the result to the cubic histogram analyzer
            self.histograCube.source = destination
        }
 
        //
        // The results of updating the analyzer calculation are displayed in the color list window
        //
        histograCube.addUpdateObserver { (histogram) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
            self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                self.paletteView.colorList = self.paletteSolver.colors
            })
        }
 
        view.addSubview(imageView)
 
....
 
        IMPDocument.sharedInstance.addDocumentObserver { (file, type) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
            if type == .Image {
                do{
                    //
                    // Load the file and associate it with the filter source
                    //
                    self.imageView.source = try IMPImageProvider(context: self.imageView.context, file: file)
                    self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                        self.zoomFit()
                    })
                }
                catch let error as NSError {
                    self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                        let alert = NSAlert(error: error)
                        alert.runModal()
                    })
                }
            }
            else if type == .LUT {
                do {
 
                    //
                    // Initialize the CLUT descriptor
                    //
                    var description = IMPImageProvider.LutDescription()
                    //
                    // Load CLUT
                    //
                    let lutProvider = try IMPImageProvider(context: self.context, cubeFile: file, description: &amp;amp;amp;amp;amp;amp;amp;amp;amp;description)
 
                    if let lut = self.lutFilter{
                        //
                        // If a CLUT filter has been added, update its LUT table from the file with the received descriptor
                        //
                        lut.update(lutProvider, description:description)
                    }
                    else{
                        //
                        // Create a new LUT filter
                        //
                        self.lutFilter = IMPLutFilter(context: self.context, lut: lutProvider, description: description)
                    }
 
                    //
                    // Add a LUT filter, if this filter has already been added nothing happens
                    //
                    self.filter.addFilter(self.lutFilter!)
                }
                catch let error as NSError {
                    self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in
                        let alert = NSAlert(error: error)
                        alert.runModal()
                    })
                }
            }
        }
 
   .... As you can see, photo processing is becoming simpler and more accessible to average users, making it possible for virtually anyone to master this process. The entire project can be downloaded, assembled, and tested from the project : . For proper assembly, the mega-library for working with JPEG files (JFIF), , must be locally installed. ImageMetalling repository ImageMetalling-08 libjpeg-turbo Currently, this is the best implementation of support for this format.

How to Create an Application to Determine the Palette and Dominant Colors of an Image

একটি চিত্রের প্যালেট এবং প্রভাবশালী রঙ নির্ধারণের জন্য কীভাবে একটি অ্যাপ্লিকেশন তৈরি করবেন

So erstellen Sie eine Anwendung zum Bestimmen der Palette und der vorherrschenden Farben eines Bildes

Cómo crear una aplicación para determinar la paleta y los colores dominantes de una imagen

Comment créer une application pour déterminer la palette et les couleurs dominantes d'une image

किसी छवि के पैलेट और प्रमुख रंगों को निर्धारित करने के लिए एप्लिकेशन कैसे बनाएं

画像のパレットと主要な色を決定するアプリケーションを作成する方法

이미지의 팔레트 및 주요 색상을 결정하는 응용 프로그램을 만드는 방법

Como criar um aplicativo para determinar a paleta e as cores dominantes de uma imagem

Как создать приложение для определения палитры и доминирующих цветов изображения

Bir Görüntünün Paletini ve Baskın Renklerini Belirlemeye Yönelik Uygulama Nasıl Oluşturulur

Cách tạo một ứng dụng để xác định bảng màu và màu chủ đạo của hình ảnh

如何创建应用程序来确定图像的调色板和主色

Startups Of The Year 2023: Asia Winners

BRAMBLE-DWELLERS

"If there is ever the chance for escape that you seem to think will some day present itself,"

Tarzan of the Apes was led directly from the Royal Dome

BOOK VIII

Astounding Stories of Super-Science July 1931: VOL. VII, No. 1 -  The Diamond Thunderbolt

Security is important! For the average human, your daily internet habits might not matter. But for hackers, well,  your data is money. Data big or small is valuable. In this blog, I’m going to discuss how we can secure our web accounts, web servers, mobiles, Windows systems & Linux systems. Blog Agenda: Web accounts. Web servers. Windows systems. Linux systems. Key points. Web Accounts: Web accounts are really easy to hack. All that the process really needs is patience. General Advice: Keeping a strong password with a minimum of 12 characters, containing numbers, small letters, capital letters, symbols, spaces, etc. Enabling 2-factor authentication using your phone number, email, or a third-party application. You can also follow these special steps to be aware of database leaks or breaches: Check password leak websites regularly for your email or username. If you find your information on these sites, then you can immediately change your credentials and also verify how much the hacker knows about you. Use tools such as Dashlane which provides password protection and dark web breach intel to you whenever it detects such an incident. Tips and Tricks: There are certain tricks you may want to follow in case you don’t want your account to be hijacked by some random hacker with the right password. You can secure your accounts by using the regular password combinations everyone follows which are symbols & numbers. But that’s a minimal level. You can do more to outsmart hackers by using s. With each increase in characters, it may take 1 million years to crack your password. ALT symbol I will be dead by that time, don’t know about the hacker. The hacker or anyone, in that case, cannot access your accounts without the right password. Sure, there are other ways such as phishing, keylogging, etc. we will look into those in a while. These are the ALT symbols and their ALT keys: ™	Alt+0153	Trademark
©	Alt+0169	Copyright
®	Alt+0174	Registered
‰	Alt+0137	Per mille (per thousand)
±	Alt+241	    Plus or Minus
¼	Alt+0188	Quarter
½	Alt+0189	Half
¾	Alt+0190	Three quarters
≡	Alt+240	    Exactly Identical
≈	Alt+247	    Approximately equal
≥	Alt+242	    Greater than or equal
≤	Alt+243	    Less than or equal
√	Alt+251	    Square Root
ⁿ	Alt+252	    Power n
¹	Alt+0185	To the power of 1
²	Alt+0178	Squared
³	Alt+0179	Cubed
π	Alt+227	    Pi
°	Alt+248	    Degree
∞	Alt+2368	Infinity
µ	Alt+230	    Micro
Σ	Alt+228	    Sum
☺	Alt+1	    White Smiley
☻	Alt+2	    Black Smiley
•	Alt+7	    Bullet 1
○	Alt+9	    Bullet 2
♂	Alt+11	    Male Sign
♀	Alt+12	    Female Sign
↨	Alt+23	    Up/Down Arrow
↑	Alt+24	    Up Arrow
↓	Alt+25	    Down Arrow
→	Alt+26	    Right Arrow
←	Alt+27	    Left Arrow
↔	Alt+29	    Right/Left Arrow
£	Alt+156	    Pound
€	Alt+0128	Euro
$	Alt+36	    Dollar Sign
¢	Alt+155	    Cent
¥	Alt+157	    Yen
ƒ	Alt+159	    Frank
₧	Alt+158	    Peseta
α	Alt+224	    Alpha
ß	Alt+225	    Beta
δ	Alt+235	    Delta
Ω	Alt+234	    Omega
►	Alt+16	    Point Right
◄	Alt+17	    Point Left
■	Alt+254	    Stop
▲	Alt+30	    Point Up
▼	Alt+31	    Point Down
§	Alt+21	    Section
¶	Alt+20	    Paragraph
“	Alt+0147	curly double open quote
”	Alt+0148	curly double close quote
«	Alt+174	    Quotation Mark
»	Alt+175	    Quotation Mark
♥	Alt+3	    Heart
º	Alt+0176	Degree symbol
œ	Alt+0156	Latin small ligature oe
•	Alt+0149	Bullet
↻	Alt+8635	Clockwise Open Circle Arrow
↺	Alt+8634	Counterclockwise Open Circle Arrow
Ø	Alt+0216	Diameter
Ñ	Alt+0209	Enye This ALT code list was compiled by postpresentation.com You can also choose 2-factor or multi-factor protection which also reduces the risk exponentially. Ultimately, those are all the processes one needs to practice in order to protect your social media accounts or any accounts in general. Web-Servers Web servers are machines accessible by anyone with the correct IP. Why do Web Servers Need Protection? Because they collect user data. This includes data not just from the admin but everyone else who is using the platform. This can be achieved by implementing firewalls, port number changes, and having regular software updates. Here is what is needed to be secured in a server: Server firewall. Database. Scan source codes to a certain level for vulnerabilities. Launch Bug bounty programs. Server firewall: The first thing to do in firewall protection is to change all of the default passwords and default users with a safe and secure password. Secondly, we need to limit the access of the firewall to as few people as possible. Ether by using blocks to other admins or even eliminate other admins’ permissions on the config files. Thirdly, disable simple network management protocol (SNMP) or configure it to use a secure community string. After the above is done we need to architect zones that we need to forbid or allow access to anyone other than the admin. The best thing to do is other than the default HTTPS service which runs on PORT:443 we need to block all unnecessary ports and change the port numbers of all the other necessary services for example: change SSH port default: 22 to port:1000 or anything else and set up a forward of all the specific traffic from the service which is SSH from port 1000 to port 22 using the firewall. This reduces the chance of any possible port scanners taking a delay in searching the specific port in the web IP. After the above is completed we need to concentrate on the ACL or access control list that contains all the rules required to provide access to a specific service in the server. To put this into context the normal person in max may have access to the web page and the admin will have access to the ssh connection (if the admin is in the same network or via an authentication portal) other than this, no one can access the various services provided by the website. ACL has a list of rules to also manage port monitoring and logging of firewall activity. After the ACL has done its job it’s recommended that an expert checks the work. If this is an industrial environment, there are network professionals who will look into the various firewall rules. They tend to modify them if they are of any threat. Database: Database security is a key element in data stability and safety. If there is a data breach the hackers can get their hands on juicy information, for example: Credit card information, phone numbers, names, address, IP, etc. This may not look like much but in the wrong hands, this information can also be used in fraud. we will look into the basic stuff things such as audits and updates which should be done regularly. Firstly, , we will look into encryption. Secondly A company should hire a cryptographer or an expert in that manner to create a unique rainbow table that can be used to store data in a much safer way. In case you are using a database such as MySQL then it comes with its encryption but it is good that you add a layer of protection upon it. backups are really important if by any means your data is blocked by malware or it is lost due to an error then backups are really handy now. Thirdly, use a separate server from the main server to store the database that has its firewall and secure environment that only the system administrator and a certain application combined can access to better ensure the protection of the database from potential malware and ransomware. Fourthly, Scan source codes to a certain level for vulnerabilities. If you are a developer then you will be familiar with Github. You can upload the source code of your application not entirely but as snippets and scan them using SYNK. Synk uses a scanner to scan the code to locate potential endpoints or libraries that can be vulnerable and gives the option to manually patch or automatically patch the code. This is particularly useful to check for developer errors before publishing. You can hire a Professional analyzer also who is internal to the organization and also conduct the code review. Launch Bug Bounty Programs Sometimes you will need external views or creative views to get to the issue. These individual hackers all over the world participate and try to hack the vulnerability which might be fatal to the company depending on the risk factor and priority of the company. If they find a potential vulnerability or a bug they are rewarded on the basis of the intensity of the bug. Where does it stand in the priority and what is it affecting? These factors play a vital role in the end payout. This is a win-win situation for both the company and the hacker. Both have profited via this program. These are the ways you can protect a web server on the backend. There are also many things to be done on the front end. I have explained various exploits done on the front end you can check out my article on that topic on that ‘self-publicity‘ . link to the article Windows Systems Windows is a commercially highly used Operating System that in all cases is important to protect. Being a Proprietary Software it does not have any kind of open-source community such as Linux to patch potential bugs for them instead they hire white hat hackers for the work. Things to be careful of in windows: Virus & Anti Virus. Phishing. unwanted services. Be far away from pirated software. Virus & Anti Virus Virus, malware, or ransomware are really common for windows systems. The best practice is to keep updating Windows Defender, and never turn off the real-time protection of the system. The virus protection from Windows or Windows Defender has an adequate amount of security to protect you from unsafe downloads. Phishing Phishing or Social Engineering is a powerful technique. It is a tool used for convincing the target to do what you intend by manipulating his thoughts. It is tough but effective. Usually, hackers pose as legit people with the same interest as you and convince you to click on links, or tell you to download certain malware on the system to gain system access to your files. Or else use the biggest weakness of a person -- his curiosity --to make him install software or connect a USB stick to his system to gain unauthorized access. Unwanted Services Services that are not in much use and are simply running in the background of the system can also lead to a lot of problems if maybe they are vulnerable and a hacker can hack them. You can use the task manager to go to their services section and disable such services from running in the background and problems solved. Beware of Pirate Software Stay away from pirated software. Remember Piracy can sometimes lead to Bankruptcy. Follow the above things and you are safe to go and use windows. Linux Systems Linux systems are open source and are constantly checked by millions of users for vulnerabilities. They are constantly patched, making it less easy to hack. Even though it is hackable. Reduce SUID File Privileges SUID privileges are Superuser privileges in Linux and using these the hacker can gain root access into the server. This is not good news for the server because by reducing the number of SUID files and keeping the rest in isolation we can reduce the chance of privilege escalation. A huge database of SUID and privilege escalation enumeration tool is Linpeas and winpeas used in Linux and windows respectively. Links to Github are used to enumerate the entire system to find SUID files and password files left by the dev team for later use. It can be used also for priv-esc. You can refer GTFOBins link to check for all the codes for priv-esc. For example, nano has SUID permissions. nano
^R^X
reset; sh 1>&0 2>&0 I can enter this and get a Root shell using nano. code copied directly from GTFOBins website Key Notes If you follow the above things there is a good chance that you might not get hacked. But it really depends on your self-safety and interest to protect your privacy. I have explained all I know on how I can help you be safe from Black hat hackers out there in the cyber world. The goal is not to scare my readers but to warn you all that if your data falls into the wrong hands you can end up in a bad situation. For example, your photos can be DeepFaked, your phone number used to mask another crime, and many more things. So be careful and be safe. If you want to know what all crazy stuff happens over on the dark web check out my other article completely covering the dark web and how to start a website in the dark web ‘self-publicity . l ink to the article Sources . GTFOBins weblink . Pro presentation website for ALT codes Contact me. INSTAGRAM TWITTER EMAIL: morpheuslord@protonmail.com

How to Protect Your Privacy From Hackers

Note that under open source projects we assume the following: Node.js frameworks;Tools which can be used in Node.js;Node.js server applications;Fullstack applications (Vue, React, Angular etc. on the front-end and Node.js on backend) which use Node.js on the server side What is Node.js? Node.js is a cross-platform, open source runtime environment for executing JavaScript code outside of the browser. It is event-driven and works on a non-blocking I/O model, making it lightweight and efficient for building web applications. Node.js is just another way to run code on your computer, being just the environment for running JavaScript. With Node.js, you can run your code simultaneously on both the client and the server side, speeding up the whole process of development. Node.js’ rising popularity has also produced a wave of open source projects and tools to help developers work with the environment. A part of our admin templates has an integrated Node.js backend (you can start getting to know our products with an angular dashboard ). Pros and Cons of Node.js Pros Uses JavaScript, which is easy to learn; Shares the same codebase with both server and client side; It has seamless JSON support; Node.js has active community, with lots of code examples. Cons It is very to hard to deal with relational databases when you use Node.js; Callback hell; Performance bottlenecks with heavy computation tasks. Reasons to use Node.js in projects You can build very fast useful tools like chats, fileuploads etc;Non-blocking code. This approach helps the application not to pause or sleep, but to become available for other requests;Fast processing. Node uses V8 JavaScript Runtime engine, the one which Google Chrome uses, and – believe us – it is very fast;One environment; A great number of tools that can help in everyday development – CMS, chats, spreadsheets, form validation and other libraries;Larger community that can provide support for free or on a commercial basis. How to choose an open-source project to contribute to Number of github stars and npm downloads This is the most valuable criteria (joking!). Obviously, just because the repo is popular/widely used, it doesn’t necessarily mean it will be useful to contribute. Still a good sign, though. Documentation Documentation is probably one of the most important things to look for when you’re assessing a project. Docs are like entry points to the project. Good documentation will usually include: A README.md file in the root of the project. This should have the public API/functions listed, as well as what they do and how to use;Examples in the documentation or a separate folder containing multiple examples;Contribution guide;FAQ. Recent development and open issues You should look at the recent issues and bugs, how they’re organized. By checking these items you can know if the project is still maintained. If it’s not, you may run into the issue of some things not working that may affect your understanding of how the project works. On the other side, if a project has a lot of open issues, don’t disqualify it: these might be questions from users, ideas or non-critical bugs. Tests Having a test would be a great addition to good docs and good code structure. Structure/Code organization How well the code is organized shows the quality of the project. See the name of the folders, comments and index.js file. Other criterias Project size; The project needs to be something you use; Something you’re interested in learning; Something that your team does use. Best node.js open source projects We tried to select the projects along several lines: more than 5,000 github stars; solving one specific problem very well; being super useful in developing web and mobile applications. SheetJS Web-site: https://sheetjs.com/ Github page: https://github.com/SheetJS/sheetjs Demo: https://sheetjs.com/demo Apache License 2.0 License: 21.7k Github stars: Yes Contribution guideline: SheetJS is a node.js library that lets you manipulate spreadsheets in Excel format. It lets you do lots of things with Excel, such as creating exporting workbooks from scratch and converting HTML tables, arrays or JSON into downloadable xlsx files. There are two versions of this tool – Community and Pro, which has extended features. The library has a large community, extensive documentation and well documented contributing guide. Overall it is a dream library: being good for just one thing, it works really amazing. Please consider it for contributing. Cytoscape.js Web-site: https://js.cytoscape.org/ Github page: https://github.com/cytoscape/cytoscape.js Demo: https://js.cytoscape.org/#demos Private license License: 6.8k Github stars: Yes Contribution guideline: Cytoscape.js is an open-source graph theory library written in JS. You can use Cytoscape.js for graph analysis and visualization. It allows you to easily display and manipulate rich, interactive graphs. Cytoscape.js includes all the gestures out-of-the-box, including pinch-to-zoom, box selection, panning, and more. Cytoscape.js also has a graph analysis. The library contains many useful functions in graph theory. You can use Cytoscape.js headlessly on Node.js to do graph analysis in the terminal or on a web server. The project is good for the people who are interested in science and data. It has great docs, contribution guide and a roadmap. PDFkit Web-site: http://pdfkit.org/ Github page: https://github.com/foliojs/pdfkit Demo: http://pdfkit.org/demo/browser.html MIT License: 6.3k Github stars: No Contribution guideline: PDFkit is a super useful PDF generation library for nodes that help to create and download complex PDFs. The library supports font embedding, text, vector graphics, annotations and other features. However, the project does not have the contribution guideline and extensive documentation, making you guess how to contribute to it. ESlint Web-site: https://eslint.org/ Github page: https://github.com/eslint/eslint Demo: https://eslint.org/demo MIT License: 16.7k Github stars: Yes Contribution guideline: ESLint is a linting tool for coding, which means it performs a static analysis of the code and finds errors, patterns and lines not fitting conventional style guidelines. This adds an extra level of checking that the code works before executing it. ESLint comes with a default set of rules, but you can change them however and whenever you want. Such big names as Facebook, Netflix, Atlassian, Zendesk, Box, and PayPal – all use ESLint. This tool is essential for web developers: it helps to fix issues even before they happen. The project has extensive documentation, contributing guide, as well as huge community and even sponsors interested in the development of this useful tool. Axios – Web-site: Github page: https://github.com/axios/axios – Demo: MIT License: 74.9k Github stars: MIT Contribution guideline: Axios is one of the most popular projects on Github that uses node.js. It is a Promise-based HTTP client for the browser and node.js. It can help you do all of these things: Make XMLHttpRequests from the browserMake http requests from node.jsSupports the Promise APIIntercept request and responseTransform request and response dataCancel requests Express.js Web-site: https://expressjs.com/ Github page: https://github.com/expressjs/express – Demo: MIT License: 49.2k Github stars: Yes Contribution guideline: This is one of the trending modular open source projects on Node.js. Express offers tremendous value since it makes HTTP requests efficient even when you are working with JavaScript, an out-of-browser and server-side language. Also, Express is a non-opinionated framework. Express is helpful with fulfilling the tasks related to app security and speed. It is very often associated with the MEAN (MongoDB, Express, Angular, Node.js) stack used to build web applications.As a part of the MEAN.io framework stack, Express.js is also the optimal choice for building enterprise-size applications. Notable features: URL-based routing mechanism using the HTTP methods; Various plugins and extensions support; Easy database integration. The tool has a very robust website with a lot of examples. Documentation is translated into several languages. Additionally, the community is strong and ready to help. A good choice to contribute to, if you’re an experienced developer. Socket.io Web-site: https://socket.io/ Github page: https://github.com/socketio/socket.io – Demo: MIT License: 50.1k Github stars: No Contribution guideline: Socket.IO enables real-time, bi-directional and event-based communication. It works on every platform, browser or device, focusing equally on reliability and speed. A popular way to demonstrate the two-way communication Socket.IO provides is a basic chat app. With sockets, when the server receives a new message, it will send it to the client and notify them, bypassing the need to send requests between client and server. Notable features: Real-time analytics; Binary streaming; Instant messaging and chat; Document collaboration (like in G Docs). Date-fns Web-site: https://date-fns.org/ Github page: https://github.com/date-fns/date-fns – Demo: MIT License: 22.8k Github stars: Yes Contribution guideline: Date-fns provides the most comprehensive, yet simple and consistent toolset for manipulating JavaScript dates in a browser & Node.js. It works well with modern module bundlers such as webpack, Browserify, or Rollup. Date-fns is built using pure functions and always returns a new date instance instead of changing the passed one. With the support of an amazing community, date-fns has dozens of locales. Every function has a detailed description with examples. The documentation is accessible both online (at the website) and offline thanks to JSDoc annotations. Also the community is really, really strong and supportive. It is totally worth investing your time in development of this tiny but helpful library. Strapi Web-site: https://strapi.io/ Github page: https://github.com/strapi/strapi Demo: https://strapi.io/demo MIT License: 27k Github stars: Yes Contribution guideline: Strapi is an open-source headless content management system (CMS). It is a backend-only system that functions using RESTful APIs. Strapi’s goal is to fetch and deliver your content in a structured manner across any device. It provides a lot of features, including file upload, a built-in email system, JSON Web Token (JWT) authentication and auto-generated documentation. In addition, the content structure built through Strapi is extremely flexible: you can create and reuse groups of content and customizable APIs. Nest Web-site: https://nestjs.com/ Github page: https://github.com/nestjs/nest – Demo: MIT License: 28.4k Github stars: Yes Contribution guideline: Nest is a progressive Node.js framework for building efficient, reliable and scalable server-side applications. It uses TypeScript, combining elements of Object Oriented Programming and Functional Programming. Under the hood, Nest uses Express, but also provides compatibility with a wide range of other libraries. Nest gives you true flexibility by allowing use of any other libraries thanks to modular architecture. The tool is very mature and useful, with a good documentation and contribution guide. Cube.js Web-site: https://cube.dev/ Github page: https://github.com/cube-js/cube.js – Demo: MIT License: 8.2k Github stars: Yes Contribution guideline: Cube.js is an open source modular framework to build analytical web applications. It is primarily used to build internal business intelligence tools or to add customer-facing analytics to an existing application. Cube.js was designed to work with Serverless Query Engines like AWS Athena and Google BigQuery. Multi-stage querying approach makes it suitable for handling trillions of data points. Most modern RDBMS work with Cube.js as well and can be tuned for adequate performance. It is essentially not a monolith application, but a set of modules, each doing one thing really well. Cube.js provides modules to run transformations and modeling in data warehouse, querying and caching, managing API gateway and building UI on top of that. We at Flatlogic even built a demo and wrote an article on how to build an application using Cube.js: you can . check it out Meteor Web-site: https://www.meteor.com/ Github page: https://github.com/meteor/meteor – Demo: MIT License: 48.1k Github stars: Yes Contribution guideline: Meteor is designed as a full-stack JavaScript platform for developing apps and solutions for web and mobile. Meteor supports all three major JS frameworks: React, Vue and Angular. The main advantages of the Meteor framework are: The same code supported across different devices; A number of ready-made modules in the default package accelerating the development; Large community offering dozens of reusable packages and modules. Giants like IKEA and Mazda use meteor for their needs. The project has an excellent web-site and documentation, feeling very mature. It is totally a good choice to contribute for professional developers. Electron Web-site: https://www.electronjs.org/ Github page: https://github.com/electron/electron – Demo: MIT License: 84.2k Github stars: Yes Contribution guideline: If you are making client-side or web-based apps, Electron will simplify the development process in a great way. It uses the same codebase for web apps and desktop apps. If a graphical user interface (GUI) is imperative for your app or product, Electron will be perfect for you. Since it deploys web technologies, it works very well even with complex UI/UX modules. Electron uses JavaScript and Node.js, as well as HTML and CSS. Electron provides great assistance when there is a need for building cool cross-platform Node JS projects for Linux, Windows or MacOS. Notable benefits: Compatibility with most platforms including Mac, Linux and Windows; Using Chromium engine enables all the best features of Chrome and the ability to use developer tools, storage access, etc.; It can be used without utilizing much of the computational power. There also are a great website, comprehensive docs and a large active community. Hackathon starter – Web-site: Github page: https://github.com/sahat/hackathon-starter Demo: https://hackathon-starter.walcony.com/ MIT License: 30.3k Github stars: No Contribution guideline: This is a boilerplate for Node.js web applications. The project is as generic and reusable as possible to cover most use cases of node.js web apps, without being too specific. You can even use this as a learning guide for your projects, if, let’s say, you’re only interested in Sign in with Google authentication and nothing else. It was built using a simple bootstrap theme and has dozens of API examples, including Instagram, Facebook etc. Features: Local Authentication using Email and Password; OAuth 2.0 Authentication via Facebook, Google, GitHub, LinkedIn, Instagram; Flash notifications; MVC Project Structure; Bootstrap 4 + Extra Themes; Contact Form; Account Management; Password Management. The authors welcome others to fix issues and contribute to the project with the new use cases. Conclusion We’ve mentioned some of the most popular and useful open source products developed on node.js. We also tried to be helpful with choosing open source projects for contribution. We hope you’ve found some interesting Node.js open source projects to try, or actively contribute to. If you found this article interesting, please share it and give us feedback! Previously published at https://flatlogic.com/blog/14-best-node-js-open-source-projects/

14 Top Node.js Open Source Projects: 2021 Edition

Quite commonly in our applications, we need to create interactive report builders to let users build custom reports and dashboards. This usually involves selecting the metrics, groupings, date ranges, filters, and chart types. To help developers build such interactive components, we've created a query builder component in Cube.js client libraries. We've already covered how to use it in the , and in this blog post, we'll talk about using it with Vue.js. The query builder component uses the technique and lets developers implement their own render logic. This way it gives maximum flexibility for building a custom-tailored UI with minimal API. Below you can see the demo of the query builder component with . React client library scoped slots Vuetify You can find the and . live demo of the example here its source code is available on Github Setup a Demo Backend *if you already have Cube.js backend up and running you can skip this step.* Let's start by setting up a database with some sample data. We'll use PostgreSQL and our example e-commerce dataset for this tutorial. You can download and import it by running the following commands. $ curl <http://cube.dev/downloads/ecom-dump.sql> > ecom-dump.sql
$ createdb ecom
$ psql --dbname ecom -f ecom-dump.sql Next, install the Cube.js CLI if you don't have it already, and create a new project. $ npm install -g cubejs-cli
$ cubejs create -d postgres vue-query-builder Cube.js uses environment variables for configuration, which starts with `CUBEJS_`. To configure the connection to our database, we need to specify the DB type and name. In the Cube.js project folder replace the contents of `.env` file with the following: CUBEJS_DB_NAME=ecom
CUBEJS_DB_TYPE=postgres
CUBEJS_API_SECRET=SECRET Now that we have everything configured, let's start the Cube.js development server with the following command. $ npm run dev Navigate to in your browser to access the Cube.js Playground. It is a development environment that generates the Cube.js schema, creates scaffolding for charts, and lets you test your queries and debug them. It also has its own query builder, which lets you generate charts with different charting libraries. http://localhost:4000 Now let’s move on to building our own query builder with Vue.js! 💻 Building a Query Builder We're going to use to generate a new project. Run the following command to install Vue CLI if you don't have it already. Vue CLI $ npm install -g @vue/cli To a create a new project with Vue CLI run the following command inside the Cube.js project folder. $ vue create dashboard-app To render the UI for query builder we are going to use , a Vue UI Library with material components. Let's add it to our project. Run the following command inside the `dashboard-app` folder. Vuetify $ vue add vuetify To create our color scheme you can open `src/plugins/vuetify.js` and add this code: import Vue from 'vue'
import Vuetify from 'vuetify/lib'

Vue.use(Vuetify)

export default new Vuetify({ }) +  theme: { +    themes: { +      light: { +        primary: '#7A77FF', +      }, +    }, +  }, Now we can start our frontend application. $ yarn serve You can check your newly created Vue app at . Next, let's install dependencies we'll need for building our Query Builder: Cube.js Vue client, Vue Chartkick, and Chart.js. http://localhost:8080 $ npm install --save vue-chartkick chart.js core-js @cubejs-client/core @cubejs-client/vue Let's create a first simple Query Builder to allow users to select the metric from the dropdown list and then render it as a line chart over time. Cube.js Query Builder component can load the list of available measures based on the data schema from the backend. We can access these measures as an `availableMeasures` slot prop. We'll render that list with the `v-select` component from Vuetify. Then when the user selects the measure, we're going to use a `setMeasures` slot prop to update the measures in our query and finally render the query result as a line chart with Vue Chartkick and Chart.js. . You can learn more about other slot props in the Query Builder component in the docs Replace the content of the `src/HelloWord.vue` file with the following. < > template < = > v-container fluid class "text-center background pa-0" < = = = > query-builder :cubejs-api "cubejsApi" :query "query" style "width: 100%" < = > template v-slot:builder "{measures,setMeasures,availableMeasures}" < = > v-container fluid class "pa-4 pa-md-8 pt-6 background-white" < > v-row < = = > v-col cols "12" md "2" < = = @ = = /> v-select multiple label "Measures" outlined hide-details :value "measures.map(i => (i.name))" change "setMeasures" :items "availableMeasures.map(i => (i.name))" </ > v-col </ > v-row </ > v-container </ > template < = > template v-slot "{ resultSet }" < = = > div class "pa-4 pa-md-8" v-if "resultSet" < = > div class "border-light pa-4 pa-md-12" < = = > line-chart legend "bottom" :data "series(resultSet)" </ > line-chart </ > div </ > div </ > template </ > query-builder </ > v-container </ > template < > script cubejs { QueryBuilder } cubejsApi = cubejs( , { : }); { : , : {
    QueryBuilder
  }, : { query = { : , : [
        { : , : , : }
      ],
    } {
      cubejsApi,
      query
    }
  }, : {
    series (resultSet) { resultSet.series().map( ({ : series.key, : series.series.map( [row.x, row.value])
      }))
    }
  }
} import from '@cubejs-client/core' import from '@cubejs-client/vue' const "CUBEJS-TOKEN" apiUrl `http://localhost:4000/cubejs-api/v1` export default name 'HelloWorld' components data => () const limit 100 timeDimensions dimension 'LineItems.createdAt' granularity 'day' dateRange 'Last 30 days' return methods return => series name data => row </ > script < > style scopped { : ; : ;
  } { : ;
  } { : ; : ;
  } .background background #F3F3FB min-height 100vh .background-white background #fff .border-light background #FFFFFF border-radius 8px </ > style Now we can use updated `HelloWorld` component in our `App` component. Replace the content of the `src/App.vue` with the following. < > template < > v-app < = > v-app-bar app color "#43436B" dark < = > div class "d-flex align-center" < = = = = /> v-img alt "Vuetify Logo" class "shrink mr-2" contain src "<https://cube.dev/downloads/logo-full.svg>" transition "scale-transition" </ > div </ > v-app-bar < > v-main < /> HelloWorld </ > v-main </ > v-app </ > template < > script HelloWorld { : , : {
    HelloWorld
  }
} import from './components/HelloWorld' export default name 'App' components </ > script The last small change we need to make is to register the `VueChartkick` plugin. Update the `src/main.js` file. import Vue from 'vue'
import App from './App.vue'
import vuetify from './plugins/vuetify' Vue.config.productionTip = false new Vue({
  vuetify,
  render: h => h(App)
}).$mount('#app') + import Chart from 'chart.js' + import VueChartkick from 'vue-chartkick' + Vue.use(VueChartkick, { adapter: Chart }) We've just built our first simple query builder 🎉. Navigate to in your browser and you should be able to test it out. http://localhost:8080/ We can already plot the count of orders over time. But what if we want to see the breakdown of orders by the status? To do so, we'd need to introduce the dimensions dropdown to let users select the grouping option. We'll use more slot props for this: `dimensions`, `availableDimensions` and `setDimensions`. They work they same as slot props for measures allowing us to list the available dimensions and update the list of selected ones. Update `src/HelloWorld.vue` file. <template>
  <v-container fluid class="text-center background pa-0">
    <query-builder :cubejs-api="cubejsApi" :query="query" style="width: 100%"> <v-container fluid class="pa-4 pa-md-8 pt-6 background-white">
            <v-row>
	          <v-col cols="12" md="2">
	            <v-select
	              multiple
	              label="Measures"
	              outlined
		          hide-details
	              :value="measures.map(i => (i.name))"
	              @change="setMeasures"
	              :items="availableMeasures.map(i => (i.name))"
	            />
	          </v-col> </v-row>
          </v-container>
        </template>
        <template v-slot="{ resultSet }">
	        <div class="pa-4 pa-md-8" v-if="resultSet">
	          <div class="border-light pa-4 pa-md-12">
	            <line-chart legend="bottom" :data="series(resultSet)"></line-chart>
	          </div>
	        </div>
	      </template>
      </query-builder>
  </v-container>
</template> -    <template v-slot:builder="{measures,setMeasures,availableMeasures}" +    <template +       v-slot:builder="{ +       measures, +       setMeasures, +       availableMeasures, +       dimensions, +       setDimensions, +       availableDimensions +       }" +     > +             <v-col cols="12" md="2"> +               <v-select +                 multiple +                 label="Dimensions" +                 outlined +                 hide-details +                 :value="dimensions.map(i => (i.name))" +                 @change="setDimensions" +                 :items="availableDimensions.map(i => (i.name))" +               /> +             </v-col> Refresh your browser and now you should be able to select the dimensions for grouping as well! That's all for this tutorial. Congratulations on completing it! 🎉 There are other controls you can add to your query builder like filters, date range, and granularity, as well as chart type selector. You can find and . a more complicated example with all these controls here its source code here on Github Please send any comments or feedback you might have to this . Thank you and I hope you found this tutorial helpful! Slack Community

Vue Query Builder with Cube.js - A Tutorial

Stories, News & Mentions about CCUBED

Ccubed’s Stories on HackerNoon