Sunday, March 12, 2023
HomeColdFusionDamaging An IPv4 Address Variety Up Into CIDR Varies In Lucee CFML...

Damaging An IPv4 Address Variety Up Into CIDR Varies In Lucee CFML

Recently, this blog site was being assaulted by a destructive star in Australia. I recognized 38 distinct IP addresses that were all jabbing as well as pushing the application, searching for weak points. The good news is, this triggered no problems for the website itself or its site visitors. Nonetheless, in the warmth of the minute, as I was including these IPs to Cloudflare’s Internet Application Firewall software (WAF) guidelines, I understood that my understanding of just how IP addresses job was fairly doing not have. I required to develop CIDR varieties for the WAF; yet, had not been certain just how to do that. Because of this, I wished to take a minute as well as experiment with IP addresses, taking an offered array as well as damaging it up right into the tightest feasible CIDR varies in Lucee CFML.

For this expedition, I’m mosting likely to make use of the Commons IP Mathematics Java collection produced by Yannis Gonianakis I have actually utilized this collection in the past to see if an offered IP address drops within a CIDR array; as well as, it’s fairly hassle-free! In addition to that, I’m mosting likely to make use of Lucee CFML’s capacity to dynamically tons container documents on the fly in createObject() calls

I do not truly understand networking procedures in any way So, I’m not mosting likely to attempt as well as clarify just how IP addresses operate in any kind of information – that’s ideal entrusted to individuals that understand what the hell they’re really discussing. Yet, for this expedition, I’ll claim that a CIDR (Egalitarian Inter-Domain Routing) array is an IP address symbols that represents an adjoining variety of IPs that can be stood for making use of a variety of right-hand little bits within an IP address.

The variety of little bits “secured down” is specified by the reduce in the CIDR array. For instance, in this CIDR array: 31

… the “31” at the end indicates that the left 31 little bits of the IP address are “secured down”, ie can not be transformed. Because of this, every one of the IP addresses in this array are stood for by a solitary vibrant little bit at the end:

00001010.00000000.00000000.0000001 *

That last little bit can either be a 1 or a 0, which indicates that this CIDR array can just stands for 2 distinct IP addresses:

  • 00001010.00000000.00000000.00000010 – finishing in .2
  • 00001010.00000000.00000000.00000011 – finishing in .3

The less “secured down” little bits in the CIDR array, the a lot more vibrant little bits there at the end, the bigger the variety of IPs that can be stood for by a solitary array. My objective in this experiment is to discover CIDR varieties that stand for an offered collection of IPs without producing varieties that include even more IPs than we desire

To do this, I’m mosting likely to sequentially pass through from the most affordable IP to the greatest IP as well as check out the “typical prefix” (ie, the variety of “secured down” little bits) in between each set of brother or sister addresses. If both brother or sisters share an usual prefix – as well as if that prefix does not enable IP addresses outside our preferred array – after that both brother or sister addresses can be component of the exact same CIDR array. Or else, both brother or sister addresses need to be divided as well as stood for by 2 various CIDR varieties.

Right here’s my formula for doing this in ColdFusion making use of the Commons-Ip-Math. At this moment, I’ll postpone all description to the remarks in the code:

<< cfscript>>.


// Some IP energy courses that will certainly assist us compute our varieties.
Ipv4 = javaNew( "com.github.jgonian.ipmath.Ipv4" );
Ipv4Range = javaNew( "com.github.jgonian.ipmath.Ipv4Range" );.

// Think of that we intend to develop CIDR (Egalitarian Inter-Domain Routing) varies that.
// include the provided min/max IP addresses. If we attempted to develop a "solitary array".
// to rule them all, we  would certainly wind up needing to develop an array bigger than we wished to.
// (which would certainly consist of IPs outside this min/max). Because of this, we need to damage this.
// array up right into a collection of tighter varieties that consist of just the IPs we have below.
minIpAddress = Ipv4.of( "" );.
maxIpAddress = Ipv4.of( "" );.

// CIDR varies job by securing down an offered variety of "prefix little bits" in the IP address.
// The IPs in an offered array are after that stood for by the extensive mix of the.
// continuing to be "suffix little bits". To develop "limited" varieties (ie, varies that just consist of the.
// IPs that we desire as well as absolutely nothing additional) we have develop sections in which the "least expensive".
// as well as the "greatest" IPs for an offered prefix loss within the variety of IPs that we desire.
// to target. To compute this, I'm mosting likely to begin at the most affordable IP as well as incrementally.
// action in the direction of the greatest IP, examining to see if the sub-slice of IPs suit a.
// limited array. If they do, they can be component of the exact same CIDR array; yet, if they.
// do not, I need to divide the sub-slice even more, producing 2 tighter varieties.
sector = {
from: minIpAddress,.
to: minIpAddress.
// Monitor all the sections that enter into our array.
varieties = [ segment ];.

// Maintain tipping up in the IP array while our existing sector's TO IP is much less than the.
// optimal IP in our preferred array.
while (isIpLessThan(, maxIpAddress)) {

following =;.

// To see if the "following" IP suits the existing sector, we need to obtain the typical.
// prefix of both IPs (ie, the variety of locked-down "prefix little bits" in the IP.
// address that incorporates both IPs); as well as, we need to ensure that stated prefix.
// does not include any kind of IPs OUTSIDE the existing sector.
commonPrefix = segment.from.getCommonPrefixLength( following );.
minPrefixIpAddress = next.lowerBoundForPrefix( commonPrefix );.
maxPrefixIpAddress = next.upperBoundForPrefix( commonPrefix );.

// If the lower-bound IP incorporated by the typical prefix is smaller sized than our.
// existing sector; or, if the upper-bound IP incorporated by the typical prefix is.
// bigger than our total IP-range; after that, we require to divide right into a brand-new sector.
// with a tighter prefix.
if (.
isIpLessThan( minPrefixIpAddress, segment.from)||
isIpGreaterThan( maxPrefixIpAddress, maxIpAddress ).
) {

sector = {
from: following,.
to: following.
ranges.append( sector );.

// If the lower/upper-bound IPs drop within our total IP-range, than we can simply.
// prolong the existing sector to consist of the provided IP and after that relocate onto the following.
// IP in the array.
} else { = following;.



// -------------------------------------------------------------------------------//.
// -------------------------------------------------------------------------------//.

// At this moment, we have actually taken our min/man IP-range as well as divided it up right into a collection of CIDR.
// varieties that stand for just the IPs that we respect.
// KEEP IN MIND: I have actually ascertained this making use of the CIDR IP-Address energies offered by.
for (sector in varieties) {

segmentRange = Ipv4Range
. from( segment.from )
. to( ).

resemble( segmentRange.toStringInCidrNotation() );.
resemble(" ... which consists of ..." );.
resemble( segmentRange.toStringInRangeNotationWithSpaces() );.
resemble( "<< br/>>" );.


// -------------------------------------------------------------------------------//.
// -------------------------------------------------------------------------------//.

/ **.
* I establish if the very first Commons-Ip-Math address is smaller sized than the 2nd one.
public boolean feature isIpLessThan(.
called for any kind of a,.
called for any kind of b.
) {

return( a.compareTo( b) < < 0 );.


/ **.
* I establish if the very first Commons-Ip-Math address is more than the 2nd one.
public boolean feature isIpGreaterThan(.
called for any kind of a,.
called for any kind of b.
) {

return( a.compareTo( b) > > 0 );.


/ **.
* I develop the Commons-Ip-Math course interpretation with the provided name.
public any kind of feature javaNew( called for string className) {

var jarPaths = [
			expandPath( "/vendor/commons-ip-math-1.32.jar" )

return( createObject( "java", className, jarPaths) );.



This code actions from as much as, damaging the array down right into "limited" CIDR varieties. As well as, when we run this ColdFusion code, we obtain the list below result: 32 ... which consists of ... 30 ... which consists of ... 29 ... which consists of ... 28 ... which consists of ... 27 ... which consists of ... 29 ... which consists of ... 32 ... which consists of ...

As you can see, the variety of IPs can not be stood for by one huge CIDR array Rather, we need to damage it up right into numerous smaller sized CIDR varieties that include the restricted collection of IPs we are targeting as well as absolutely nothing even more

ASIDE: As I was dealing with this ColdFusion formula, I was making use of the IP Address Overview CIDR devices to both comprehend the restrictions of the issue as well as to validate that my result matched their result. Much version was required to obtain this right!

This article utilizes IPv4 addresses; yet, I think that a formula for IPv6 addresses would certainly function similarly, just with a significantly larger array of feasible addresses. Ideally, I really did not obtain any one of this as well incorrect, practically. Like I stated previously, I do not truly comprehend anything concerning networking. Yet, infant actions such as this are gradually completing the voids.

Wish to make use of code from this article?
Have a look at the certificate


Most Popular

Recent Comments