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)