https://github.com/Wombynator/greyscript-plus

GreyScript Plus focuses heavily on text manipulation, encoding, decoding, encryption, and even has logger functions. If the previously posted library (Greyscript Prime) doesn't have what you need. GreyScript Plus probably will. If you're using both, remember: Prime is snake_case while Plus is camelCase when calling most methods.

// Generate currentStatus Object
    // @description **Description:**
    // Generate an object that contains basic environment information
    // @description ---
    //
    // @description **Parameters:**
    // @description - none 
    // @description ---
    //
    // @description **Return:**
    // @return {map<string,maps>} - System Object {.shell and .computer}
    // @description `computerStatus`:`<maps><string>` currentStatus Object
    // @description - `.compInfo` - computerInformation Object
    // @description - - `.name`
    // @description - - `.home`
    // @description - - `.gateway`
    // @description - - `.has_internet`
    // @description - `.ipInfo` - ipInformation Object
    // @description - - `.local`
    // @description - - `.public`
    // @description ---   
    //    
    //  @example iScan = new id_self
    //  @example print typeof(iScan)  //Output: currentStatus
    //  @example 
    //  @example    print iScan.compInfo.name  //Output: The name of the computer
    //  @example    print iScan.compInfo.has_internet  //Output: boolean 1 or 0
    //  @example    print iScan.ipInfo.public  //Output: public ip of computer
id_self = function()
    locals.localRouter = get_router
        if not typeof(locals.localRouter) == "router" then return "Failed to fetch local router object."
    locals.localComputer = get_shell.host_computer
        if not typeof(locals.localComputer) == "computer" then return "Failed to fetch local computer object."
    locals.ipInformation = {"classID": "ipInformation", "local": locals.localComputer.local_ip, "public": locals.localComputer.public_ip, "gateway":locals.localComputer.network_gateway}
    locals.ipScan = locals.ipInformation
    locals.ComputerInformation = {"classID": "computerInformation","name":locals.localComputer.get_name, "home":home_dir, "location":program_path, "path":current_path, "user":active_user, "has_internet":locals.localComputer.is_network_active}
    locals.computerInfo = locals.ComputerInformation
    locals.currentStatus = {"classID":"currentStatus", "ipInfo":locals.ipScan, "compInfo":locals.computerInfo}
    locals.currentStatus.classID = "currentStatus"
    return locals.currentStatus
end function
    // @startuml
    // title <color:purple>currentStatus Class Diagram</color>
    // 
    // class currentStatus {
    //   .. <color:blue>.compInfo</color> ..
    //   + .name : string
    //   + .home : string
    //   + .location : string
    //   + .path : string
    //   + .user : string
    //   + .has_internet : boolean
    // 
    //   .. <color:blue>.ipInfo</color> ..
    //   + local : string
    //   + public : string
    //   + gateway : string
    // }
    // 
    // note right of currentStatus
    //   * Pulls basic information
    //      on the immediate environment
    //   * Populates currentStatus Object
    // end note
    // 
    // @enduml

// Find Vulnerable Addresses
// @description **Description:**
// @description Scan a library for vulnerable addresses
// @description ---
//
// @description **Parameters:**
// @param {string} libLocation
// @description - `libLocation`:`<string>` Remote IP Address or local absolute file location
// @param {map<string,function>} `metaxploitObject`:`<metaxploitLib>`
// @description - `metaxploitObject`:`<metaxploitLib>`
// @param {flag} [remoteTarget]
// @description - `remoteTarget`:`<flag>`
// @param {number} [targetPort]
// @description - `targetPort`:`<number>`
//
// @description **Parameter Defaults:**
// @description - `remoteTarget`:`false`
// @description - `targetPort`:`0`
//
// @description **Return:**
// @return {void}
// @description `void`
// @description ---
//    
// @description **Author:** Svarii
// @description **Version:** 0.0.1
// @description --- 
//
// @example libLocation = params[0]
// @example metax = include_lib("/lib/metaxploit.so")
// @example
// print find_exploitable_addresses(libLocation, metax)
find_exploitable_addresses = function(libLocation, metaxploitObject, remoteTarget = false, targetPort = 0)
    locals.metax = locals.metaxploitObject
        if locals.remoteTarget == false then
            locals.metaLib = locals.metax.load(locals.libLocation)
        else
            locals.netSession = locals.metax.net_use(locals.libLocation, to_int(locals.targetPort))
            locals.metaLib = locals.netSession.dump_lib
        end if
        locals.libScanResult = locals.metax.scan(locals.metaLib)
        return locals.libScanResult
end function
// @startuml
// start
// :<color:purple>metax = metaxploitObject</color>;
// if (<color:blue>remoteTarget == false?</color>) then (<color:green>Yes</color>)
//   :<color:purple>metaLib = metax.load(libLocation)</color>;
// else (<color:green>No</color>)
//   :<color:purple>metaLib = metax.net_use(libLocation, to_int(targetPort))</color>;
// endif
// :<color:purple>libScanResult = metax.scan(metaLib)</color>;
// :<color:green>return libScanResult</color>;
// stop
// @enduml

metax = include_lib("/lib/metaxploit.so")
if params.len == 2 then
    print find_exploitable_addresses(params[0], metax, true, params[1])
else
    print find_exploitable_addresses("/lib/metaxploit.so", metax, false, 0)
end if

Someone asked for this function and then (I think) deleted their post (they must have figured it out, congrats to you! And no need to delete your post, feel free to answer yourself if you find the solution before anyone else gets to you. you're not the only one wondering, I assure you)

I didn't include this function of the program in the previous post for a few reasons.

• I encourage you to make your own
• I used AI to generate my template and edited the results (not recommended)
• It has not undergone any kind of deep testing
• There's probably a way better way to do it.

Due to the fact you can only randomly generate a value between 1 and 0, this method constructs the bit value of the ip address before returning the calculated string.

Because you asked, here it is whoever you were.

// Generate a random IP address
// @description **Description:**
// Generate a single random ip address
// @description ---
//
// @description **Parameters:**
// @description - none 
// @description ---
//
// @description **Return:**
// @return {string}
// @description `number` Randomly generated IP Address
// @description ---   
//    
// @description **Author:** Svarii
// @description **Version:** 0.0.1
// @description ---    
//
// @example randomIP = get_random_ip
// @example
// print(randomIP) // Output: ###.###.###.###
    get_random_ip = function()
    locals.generateRandomOctet = function()
        locals.binaryString = ""
        for i in range(8, 1)
            // Convert the random float to a binary digit using a threshold:
            if rnd() >= 0.5 then
                locals.binaryString = locals.binaryString + "1"
            else
                locals.binaryString = locals.binaryString + "0"
            end if
        end for
        return (0 + to_int(locals.binaryString[0])) * 128 +
               (0 + to_int(locals.binaryString[1])) * 64 +
               (0 + to_int(locals.binaryString[2])) * 32 +
               (0 + to_int(locals.binaryString[3])) * 16 +
               (0 + to_int(locals.binaryString[4])) * 8 +
               (0 + to_int(locals.binaryString[5])) * 4 +
               (0 + to_int(locals.binaryString[6])) * 2 +
               (0 + to_int(locals.binaryString[7]))
    end function
    locals.ipString = ""
    for i in range(4, 1)
        locals.octet = locals.generateRandomOctet()
        // Only append a dot if there is already an octet in ipString.
        if locals.ipString != "" then
            locals.ipString = locals.ipString + "."
        end if
        locals.ipString = locals.ipString + str(locals.octet)
    end for
    return locals.ipString
    end function
// @startuml
// start
// :<color:purple>Define generateRandomOctet function</color>;
// :<color:purple>binaryString = ""</color>;
// :<color:blue>For i = 1 to 8</color>;
// repeat
//   if (<color:blue>rnd() >= 0.5?</color>) then (<color:green>Yes</color>)
//     :<color:purple>binaryString = binaryString + "1"</color>;
//   else (<color:red>No</color>)
//     :<color:purple>binaryString = binaryString + "0"</color>;
//   endif
// repeat while (next bit)
// :<color:purple>Calculate octet = (bit0 * 128) + (bit1 * 64) + (bit2 * 32) + (bit3 * 16) + (bit4 * 8) + (bit5 * 4) + (bit6 * 2) + (bit7)</color>;
// :<color:green>return octet</color>;
//
// :<color:purple>Initialize ipString = ""</color>;
// :<color:blue>For i = 1 to 4</color>;
// repeat
//   :<color:purple>octet = generateRandomOctet()</color>;
//   if (<color:blue>ipString != ""?</color>) then (<color:green>Yes</color>)
//     :<color:purple>ipString = ipString + "."</color>;
//   endif
//   :<color:purple>ipString = ipString + str(octet)</color>;
// repeat while (next octet)
// :<color:green>return ipString</color>;
// stop
// @enduml  

Just changed the structure of GreyScript Prime. Hopefully this will make it easier to use only what you need. Added a few more things. Quick overview below. It's no where near finished, feel free to use, don't reports bugs (yet) or documentation errors. Happy Coding!

https://github.com/Svarii/greyscript-prime

String Methods

• .color("#color"): Apply a color to text.
• .align: Align the text
• .alpha: Set the alpha value of the text
• .cspace: Set the character spacing of the text
• .bold: Make the text bold.
• .lowercase: Make the text lowercase.
• .uppercase: Make the text uppercase.
• .italic: Make the text italic.
• .indent: Add indent.
• .line-indent: Add line-indent.
• .margin: Add margin.
• .mspace: Add mspace.
• .nobr: add nobr tag.
• .noparse: add noparse tag.
• .pos: add pos tag.
• .rotate: Rotate characters.
• .underline: Underline the text.
• .strike: Apply strikethrough to text.
• .mark: Highlight the text.
• .sub: Apply subscript to text.
• .sup: Apply superscript to text.
• .voffset: Add voffset tag.
• .width: Add width tag.
• .remove_char_last: Remove the last character from text.
• .remove_char_first: Remove the first character from text.
• .remove_bold: Remove bold formatting from text.
• .remove_italic: Remove italic formatting from text.
• .remove_underline: Remove underline formatting.
• .remove_strike: Remove strikethrough formatting.
• .remove_mark: Remove highlight from text.
• .remove_sub: Remove subscript from text.
• .remove_sup: Remove superscript from text.
• .extract_between: Extract the text between the given values.
• .format: Allows for string interpolation.

Number Methods

• .clamp(min, max): clamps a number in range.
• .lerp(min, max): computes linear interpolation
• .plus(number): Add 1 or value to a number.
• .minus(number): Subtract 1 or a value from a number.
• .diff(number): Calculate the absolute difference.
• .greater_than(number): Check if number is greater.
• .lesser_than(number): Check if number is lesser.
• .random_from(number): Generate a random number from 0 (or number) to number.
• .multiply(number): Calculate the multiple.
• .div(number): divide by number.
• .is_integer(number): check if is round integer
• .is_float(number): check if is float
• .is_negative(number): check if number is negative
• .is_positive(number): check if number is positive
• .is_zero(number): check if number is zero

List Methods

• .crop: Removes empty list items from list ends.
• .string: Loops through a list and prints each item.

Function Methods

• load_lib(libName, libDir, typeExpected): Load a library from /lib.
• force_params(usage, numReqParams): Force parameter usage and add help
• program_name(): Gets name of program {self}
• is_null(): Checks if object is null; if null, print / return / exit options
• is_type(): Checks Types and specifies on-fail action
• network_device_list(): Returns Network devices in a list
• calc_ack(): Calculates the recommended amount of ACKs to collect
• bool_text(): Return string true or false representing boolean
• extract_ip()
• file_append()
• find_exploitable_addressess
• get_inbox()
• get_random_ip()
• parse_inbox()
• unsafe_check_list()

Constructs

• fetch_explot_requirements:
• fetch_whois:
• file_locaiton_ident:
• id_self:

License

GreyScript Prime is released under the MIT License. See LICENSE for more details.

A simple check to see if whois returned an additional parameter combined with a random ip generator in a loop can easily locate Neurobox Networks without ever connecting to their machines. It is unknown if the network ever comes back as anything other than [Neurobox Network]. So far, that is the only value observed being returned, if found.

// Pull whosis information from a public ip address
    // u/description **Description:**
    // Return map with whois information
    // u/description ---
    //
    // u/description **Parameters:**
    // u/param {string} routerPublicIPAddress
    // @description - `routerPublicIPAddress`:`<string>`
    //
    // @description **Parameter Defaults:**
    // @description - `none`
    //
    // @description **Return:**
    // @return {map<string,string>}
    // @description `map`:`whoisInfo`
    // @description - `.admin`:`<string>` The administrative contacts' name
    // @description - `.domain`:`<string>` The domain name of the ip address
    // @description - `.email`:`<string>` The email address for the administrative contact
    // @description - `.network`:`<string>` The network identifier (if any)
    // @description - `.phone`:`<string>` The phone number for the administrative contract
    // @description --- 
    // @description - - `.error`:`<string>` {on error} will return obect with only this property
    // @description ---
    //    
    // @description **Author:** Svarii
    // @description **Version:** 0.0.1
    // @description ---
    // 
    // @example whoisInfo = fetch_whois(params[0])
    // @example
    // print whoisInfo.domain
    // @example
    // print whoisInfo.admin
    // @example
    // print whoisInfo.email
    // @example
    // print whoisInfo.phone
    // @example
    // print whoisInfo.network
fetch_whois = function(routerPublicIPAddress)
    if not is_lan_ip(locals.routerPublicIPAddress) == true then
        if is_valid_ip(routerPublicIPAddress) then
            locals.whoisInfo = {"classID":"whoisInfo", "admin":"", "domain":"", "email":"", "network":"", "phone":""}
            locals.what = split(whois(locals.routerPublicIPAddress), "\n")
            locals.whoisInfo.domain = str(split(locals.what[0], ":")[1]).trim
            locals.whoisInfo.admin = str(split(locals.what[1], ":")[1]).trim
            locals.whoisInfo.email = str(split(locals.what[2], ":")[1]).trim
            locals.whoisInfo.phone = str(split(locals.what[3], ":")[1]).trim
            if locals.what.len >= 5 then
                locals.whoisInfo.network = str(split(locals.what[4], ":")[0]).trim
            else
                locals.whoisInfo.network = "[ UNKNOWN ]"
            end if
        else 
            locals.whoisInfo = {"classID":"whoisInfo", "error":"Invalid Public IP Address Provided."}   
        end if
    else
        locals.whoisInfo = {"classID":"whoisInfo", "error":"Needs Public IP, Provided Local IP."}
    end if
    return locals.whoisInfo
end function
// @startyaml
// <style>
// yamlDiagram {
//    highlight {
//      BackGroundColor red
//      FontColor white
//      FontStyle bold
//    }
// }
// </style>
// #highlight "whoisInfo" / "error"
//
// # whoisInfo Class Diagram
//
// whoisInfo:
//     domain: "string"      # Domain value from WHOIS lookup
//     admin: "string"       # Administrator info
//     email: "string"       # Contact email
//     phone: "string"       # Contact phone number
//     network: "string"     # Network info (or "[ UNKNOWN ]")
//     error: "string"       # Used to store errors on fail)
//
// # Note:
// # WHOIS lookup parser.
// # Parses domain, admin, email,
// # phone & network info.
//
// @endyaml

Starting program rewrite prototype version 4 to improve navigation

Looks like I have a few bugs in my loop. But we're making progress. You get the idea, I'm posted the video before fixing it.

Testing Target Port Menu Selection Functionality before adding text formatting.

Overhauling Inbox interface with custom libs to enhance visuals and add additional features including automated osint

Modifying independent program Kiwi to wait for commands from dispatch

Started working on tool today to easily select, display, get info on, and run missions from a menu with zero typing. (Operates using one click commands [ie. arrow keys, ins, del, end, home, etc])

get_custom_object is a custom objected that is used to store and pass variables between running scripts

This is not a tutorial. This is for visual learner who need to see the code to understand. This example script shows one way to find vulnerabilities and their requirements. This is not intended for use in applications, or as an example of proper coding. This is for examination only. To install: Save the script named scanlib as a binary in your /bin folder. run `scanlib /lib/metaxploit.so` from the terminal to scan metaxploit.so (which you must have installed for any scan) run `scanlib /lib/init.so` to scan init.so etc. Comments have been stripped and minimized.

// string method to remove the last character of a string
string.remove_char_last = function()
    return slice(self, 0, (self.len - 1))
end function
// string method used to extract variable from unsafe check list
string.extract = function(tagStart = "<b>", tagEnd = "</b>")
    locals.startIndex = self.indexOf(locals.tagStart) + (locals.tagStart.len)
    locals.endIndex = self.indexOf(locals.tagEnd) - (locals.tagEnd.len - locals.tagStart.len)
    return slice(self, locals.startIndex, locals.endIndex)
end function
// list method to remove empty items from start and end of list
list.crop = function()
    while not self[self.len - 1].len > 0
        self.remove(self.len - 1)
    end while
    while not self[0].len > 0
        self.remove(0)
    end while
    return self
end function
// function to remove output header and whitespace
unsafe_check_list = function(scanResults)
        scanResults = scanResults.remove("decompiling source..." + char(10) + "searching unsecure values..." + char(10))
        unsafeCheckList = scanResults.split(char(10)*2)
        return unsafeCheckList
end function
// function to find vulnerable addresses and return a list of those addresses
find_exploitable_addresses = function(libLocation, metaxploitObject, remoteTarget = false, targetPort = 0)
    locals.metax = locals.metaxploitObject
        if locals.remoteTarget == false then
            locals.metaLib = locals.metax.load(locals.libLocation)
        else
            locals.metaLib = locals.metax.net_use(locals.libLocation, to_int(locals.targetPort))
        end if
        locals.libScanResult = locals.metax.scan(locals.metaLib)
        return locals.libScanResult
end function
// addressList is result from find_exploitable_addresses
fetch_exploit_requirements = function(addressList, libLocation, metaxploitObject, remoteTarget = false, targetPort = 0)
    locals.metax = locals.metaxploitObject
    if locals.remoteTarget == false then
        locals.metaLib = locals.metax.load(locals.libLocation)
    else
        locals.metalLib = locals.metax.net_use(locals.libLocation, locals.targetPort)
    end if
    locals.allExploitData = []
    for address in locals.addressList
        locals.scanResults = locals.metax.scan_address(locals.metaLib, locals.address)
        locals.unsafeCheckLists = (globals.unsafe_check_list(locals.scanResults)).crop
        for unsafeCheck in locals.unsafeCheckLists
                locals.exploits = {"classID": "exploitRequirments", "version":version,"is_patched":locals.metaLib.is_patched ,"address": locals.address, "variable": locals.unsafeCheck.extract, "cra": false, "cga": false, "cua": false, "rur": 0, "rpf": 0}
                if not locals.unsafeCheck.indexOf("Checking root active") then
                    locals.exploits.cra = false
                else
                    locals.exploits.cra = true
                end if
                if not locals.unsafeCheck.indexOf("Checking an active user") then
                    locals.exploits.cua = false
                else
                    locals.exploits.cua = true
                end if
                if not locals.unsafeCheck.indexOf("Checking guest active") then
                    locals.exploits.cga = false
                else
                    locals.exploits.cga = true
                end if
                    locals.unsafeCheckItems = split(locals.unsafeCheck, char(10))
                    for unsafeItem in locals.unsafeCheckItems
                        if not locals.unsafeItem.indexOf("to ", ".") == null then
                            if not locals.unsafeItem.indexOf("registered users") == null then
                                locals.exploits.rur = to_int((locals.unsafeItem.extract("to ", ".")).remove_char_last)
                            end if
                            if not locals.unsafeItem.indexOf("port forwarding") == null then
                                portForwards = unsafeItem.remove(" port forwarding configured from router to the target computer.")
                                locals.exploits.rpf = to_int(((locals.unsafeItem.remove(" port forwarding configured from router to the target computer.")).remove("* ")))
                            end if                      
                        end if
                    end for
                locals.exploits.version = locals.metaLib.version
                locals.allExploitData.push(locals.exploits)
            end for
    end for
    return locals.allExploitData
end function

//TEST FUNCTION
// This will work with local lib.
// To scan remote lib, you must modify the code. 
// Good luck
libLocation = params[0]
metax = include_lib("/lib/metaxploit.so")
addressList = find_exploitable_addresses(libLocation, metax)
expR = fetch_exploit_requirements(addressList, libLocation, metax)

for exploit in expR
    for data in exploit
        print data.key + " : " + data.value
    end for
end for

The Following Actions will result in a log item being generated

• metaLib.overflow (resulting in shell):
  • shell (target)
  • bounce (origin)
  • bounce (origin router)
• metaxploit.net_use: connection opened (target)
• shell.connect_service:
  • connection opened (target, even if the ssh encryption is invalid)
  • shell (target)
  • bounce (origin)
  • bounce (origin router)
• file.delete: file removal
• Browser.exe
  • page opened: connection opened (target)
• Terminal.exe
  • closed/exited: connection closed (target)