Module: Rex::Text
- Defined in:
- lib/rex/text.rb
Overview
This class formats text in various fashions and also provides a mechanism for wrapping text at a given column.
Defined Under Namespace
Classes: IllegalSequence
Constant Summary collapse
- TLDs =
Constants
['com', 'net', 'org', 'gov', 'biz', 'edu']
- States =
["AK", "AL", "AR", "AZ", "CA", "CO", "CT", "DE", "FL", "GA", "HI", "IA", "ID", "IL", "IN", "KS", "KY", "LA", "MA", "MD", "ME", "MI", "MN", "MO", "MS", "MT", "NC", "ND", "NE", "NH", "NJ", "NM", "NV", "NY", "OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VA", "VT", "WA", "WI", "WV", "WY"]
- UpperAlpha =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- LowerAlpha =
"abcdefghijklmnopqrstuvwxyz"
- Numerals =
"0123456789"
- Base32 =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
- Base64 =
UpperAlpha + LowerAlpha + Numerals + '+/'
- Base64Url =
UpperAlpha + LowerAlpha + Numerals + '-_'
- Alpha =
UpperAlpha + LowerAlpha
- AlphaNumeric =
Alpha + Numerals
- HighAscii =
[*(0x80 .. 0xff)].pack("C*")
- LowAscii =
[*(0x00 .. 0x1f)].pack("C*")
- DefaultWrap =
60
- AllChars =
[*(0x00 .. 0xff)].pack("C*")
- Punctuation =
( [*(0x21 .. 0x2f)] + [*(0x3a .. 0x3F)] + [*(0x5b .. 0x60)] + [*(0x7b .. 0x7e)] ).flatten.pack("C*")
- DefaultPatternSets =
[ Rex::Text::UpperAlpha, Rex::Text::LowerAlpha, Rex::Text::Numerals ]
- Iconv_IBM1047 =
The Iconv translation table for IBM’s mainframe / System Z (z/os, s390, mvs, etc) - This is a different implementation of EBCDIC than the Iconv_EBCDIC below. It is technically referred to as Code Page IBM1047. This will be net new (until Ruby supports 1047 code page) for all Mainframe / SystemZ based modules that need to convert ASCII to EBCDIC
The bytes are indexed by ASCII conversion number e.g. Iconv_IBM1047 == xc1 for letter “A”
Note the characters CANNOT be assumed to be in any logical order. Nor are the tables reversible. Lookups must be for each byte gist.github.com/bigendiansmalls/b08483ecedff52cc8fa3
[ "\x00","\x01","\x02","\x03","\x37","\x2d","\x2e","\x2f", "\x16","\x05","\x15","\x0b","\x0c","\x0d","\x0e","\x0f","\x10", "\x11","\x12","\x13","\x3c","\x3d","\x32","\x26","\x18","\x19", "\x3f","\x27","\x1c","\x1d","\x1e","\x1f","\x40","\x5a","\x7f", "\x7b","\x5b","\x6c","\x50","\x7d","\x4d","\x5d","\x5c","\x4e", "\x6b","\x60","\x4b","\x61","\xf0","\xf1","\xf2","\xf3","\xf4", "\xf5","\xf6","\xf7","\xf8","\xf9","\x7a","\x5e","\x4c","\x7e", "\x6e","\x6f","\x7c","\xc1","\xc2","\xc3","\xc4","\xc5","\xc6", "\xc7","\xc8","\xc9","\xd1","\xd2","\xd3","\xd4","\xd5","\xd6", "\xd7","\xd8","\xd9","\xe2","\xe3","\xe4","\xe5","\xe6","\xe7", "\xe8","\xe9","\xad","\xe0","\xbd","\x5f","\x6d","\x79","\x81", "\x82","\x83","\x84","\x85","\x86","\x87","\x88","\x89","\x91", "\x92","\x93","\x94","\x95","\x96","\x97","\x98","\x99","\xa2", "\xa3","\xa4","\xa5","\xa6","\xa7","\xa8","\xa9","\xc0","\x4f", "\xd0","\xa1","\x07","\x20","\x21","\x22","\x23","\x24","\x25", "\x06","\x17","\x28","\x29","\x2a","\x2b","\x2c","\x09","\x0a", "\x1b","\x30","\x31","\x1a","\x33","\x34","\x35","\x36","\x08", "\x38","\x39","\x3a","\x3b","\x04","\x14","\x3e","\xff","\x41", "\xaa","\x4a","\xb1","\x9f","\xb2","\x6a","\xb5","\xbb","\xb4", "\x9a","\x8a","\xb0","\xca","\xaf","\xbc","\x90","\x8f","\xea", "\xfa","\xbe","\xa0","\xb6","\xb3","\x9d","\xda","\x9b","\x8b", "\xb7","\xb8","\xb9","\xab","\x64","\x65","\x62","\x66","\x63", "\x67","\x9e","\x68","\x74","\x71","\x72","\x73","\x78","\x75", "\x76","\x77","\xac","\x69","\xed","\xee","\xeb","\xef","\xec", "\xbf","\x80","\xfd","\xfe","\xfb","\xfc","\xba","\xae","\x59", "\x44","\x45","\x42","\x46","\x43","\x47","\x9c","\x48","\x54", "\x51","\x52","\x53","\x58","\x55","\x56","\x57","\x8c","\x49", "\xcd","\xce","\xcb","\xcf","\xcc","\xe1","\x70","\xdd","\xde", "\xdb","\xdc","\x8d","\x8e","\xdf" ]
- Iconv_ISO8859_1 =
This is the reverse of the above, converts EBCDIC -> ASCII The bytes are indexed by IBM1047(EBCDIC) conversion number e.g. Iconv_ISO8859_1 = x41 for letter “A”
Note the characters CANNOT be assumed to be in any logical (e.g. sequential) order. Nor are the tables reversible. Lookups must be done byte by byte
[ "\x00","\x01","\x02","\x03","\x9c","\x09","\x86","\x7f", "\x97","\x8d","\x8e","\x0b","\x0c","\x0d","\x0e","\x0f","\x10", "\x11","\x12","\x13","\x9d","\x0a","\x08","\x87","\x18","\x19", "\x92","\x8f","\x1c","\x1d","\x1e","\x1f","\x80","\x81","\x82", "\x83","\x84","\x85","\x17","\x1b","\x88","\x89","\x8a","\x8b", "\x8c","\x05","\x06","\x07","\x90","\x91","\x16","\x93","\x94", "\x95","\x96","\x04","\x98","\x99","\x9a","\x9b","\x14","\x15", "\x9e","\x1a","\x20","\xa0","\xe2","\xe4","\xe0","\xe1","\xe3", "\xe5","\xe7","\xf1","\xa2","\x2e","\x3c","\x28","\x2b","\x7c", "\x26","\xe9","\xea","\xeb","\xe8","\xed","\xee","\xef","\xec", "\xdf","\x21","\x24","\x2a","\x29","\x3b","\x5e","\x2d","\x2f", "\xc2","\xc4","\xc0","\xc1","\xc3","\xc5","\xc7","\xd1","\xa6", "\x2c","\x25","\x5f","\x3e","\x3f","\xf8","\xc9","\xca","\xcb", "\xc8","\xcd","\xce","\xcf","\xcc","\x60","\x3a","\x23","\x40", "\x27","\x3d","\x22","\xd8","\x61","\x62","\x63","\x64","\x65", "\x66","\x67","\x68","\x69","\xab","\xbb","\xf0","\xfd","\xfe", "\xb1","\xb0","\x6a","\x6b","\x6c","\x6d","\x6e","\x6f","\x70", "\x71","\x72","\xaa","\xba","\xe6","\xb8","\xc6","\xa4","\xb5", "\x7e","\x73","\x74","\x75","\x76","\x77","\x78","\x79","\x7a", "\xa1","\xbf","\xd0","\x5b","\xde","\xae","\xac","\xa3","\xa5", "\xb7","\xa9","\xa7","\xb6","\xbc","\xbd","\xbe","\xdd","\xa8", "\xaf","\x5d","\xb4","\xd7","\x7b","\x41","\x42","\x43","\x44", "\x45","\x46","\x47","\x48","\x49","\xad","\xf4","\xf6","\xf2", "\xf3","\xf5","\x7d","\x4a","\x4b","\x4c","\x4d","\x4e","\x4f", "\x50","\x51","\x52","\xb9","\xfb","\xfc","\xf9","\xfa","\xff", "\x5c","\xf7","\x53","\x54","\x55","\x56","\x57","\x58","\x59", "\x5a","\xb2","\xd4","\xd6","\xd2","\xd3","\xd5","\x30","\x31", "\x32","\x33","\x34","\x35","\x36","\x37","\x38","\x39","\xb3", "\xdb","\xdc","\xd9","\xda","\x9f" ]
- Iconv_EBCDIC =
The Iconv translation table. The Iconv gem is deprecated in favor of String#encode, yet there is no encoding for EBCDIC. See #4525
[ "\x00", "\x01", "\x02", "\x03", "7", "-", ".", "/", "\x16", "\x05", "%", "\v", "\f", "\r", "\x0E", "\x0F", "\x10", "\x11", "\x12", "\x13", "<", "=", "2", "&", "\x18", "\x19", "?", "'", "\x1C", "\x1D", "\x1E", "\x1F", "@", "Z", "\x7F", "{", "[", "l", "P", "}", "M", "]", "\\", "N", "k", "`", "K", "a", "\xF0", "\xF1", "\xF2", "\xF3", "\xF4", "\xF5", "\xF6", "\xF7", "\xF8", "\xF9", "z", "^", "L", "~", "n", "o", "|", "\xC1", "\xC2", "\xC3", "\xC4", "\xC5", "\xC6", "\xC7", "\xC8", "\xC9", "\xD1", "\xD2", "\xD3", "\xD4", "\xD5", "\xD6", "\xD7", "\xD8", "\xD9", "\xE2", "\xE3", "\xE4", "\xE5", "\xE6", "\xE7", "\xE8", "\xE9", nil, "\xE0", nil, nil, "m", "y", "\x81", "\x82", "\x83", "\x84", "\x85", "\x86", "\x87", "\x88", "\x89", "\x91", "\x92", "\x93", "\x94", "\x95", "\x96", "\x97", "\x98", "\x99", "\xA2", "\xA3", "\xA4", "\xA5", "\xA6", "\xA7", "\xA8", "\xA9", "\xC0", "O", "\xD0", "\xA1", "\a", nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil ]
- Iconv_ASCII =
[ "\x00", "\x01", "\x02", "\x03", "\x04", "\x05", "\x06", "\a", "\b", "\t", "\n", "\v", "\f", "\r", "\x0E", "\x0F", "\x10", "\x11", "\x12", "\x13", "\x14", "\x15", "\x16", "\x17", "\x18", "\x19", "\x1A", "\e", "\x1C", "\x1D", "\x1E", "\x1F", " ", "!", "\"", "#", "$", "%", "&", "'", "(", ")", "*", "+", ",", "-", ".", "/", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ":", ";", "<", "=", ">", "?", "@", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", nil, "\\", nil, nil, "_", "`", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "{", "|", "}", "~", "\x7F", nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil ]
- Surnames =
Most 100 common surnames, male/female names in the U.S. (names.mongabay.com/)
[ "adams", "alexander", "allen", "anderson", "bailey", "baker", "barnes", "bell", "bennett", "brooks", "brown", "bryant", "butler", "campbell", "carter", "clark", "coleman", "collins", "cook", "cooper", "cox", "davis", "diaz", "edwards", "evans", "flores", "foster", "garcia", "gonzales", "gonzalez", "gray", "green", "griffin", "hall", "harris", "hayes", "henderson", "hernandez", "hill", "howard", "hughes", "jackson", "james", "jenkins", "johnson", "jones", "kelly", "king", "lee", "lewis", "long", "lopez", "martin", "martinez", "miller", "mitchell", "moore", "morgan", "morris", "murphy", "nelson", "parker", "patterson", "perez", "perry", "peterson", "phillips", "powell", "price", "ramirez", "reed", "richardson", "rivera", "roberts", "robinson", "rodriguez", "rogers", "ross", "russell", "sanchez", "sanders", "scott", "simmons", "smith", "stewart", "taylor", "thomas", "thompson", "torres", "turner", "walker", "ward", "washington", "watson", "white", "williams", "wilson", "wood", "wright", "young" ]
- Names_Male =
[ "aaron", "adam", "alan", "albert", "andrew", "anthony", "antonio", "arthur", "benjamin", "billy", "bobby", "brandon", "brian", "bruce", "carl", "carlos", "charles", "chris", "christopher", "clarence", "craig", "daniel", "david", "dennis", "donald", "douglas", "earl", "edward", "eric", "ernest", "eugene", "frank", "fred", "gary", "george", "gerald", "gregory", "harold", "harry", "henry", "howard", "jack", "james", "jason", "jeffrey", "jeremy", "jerry", "jesse", "jimmy", "joe", "john", "johnny", "jonathan", "jose", "joseph", "joshua", "juan", "justin", "keith", "kenneth", "kevin", "larry", "lawrence", "louis", "mark", "martin", "matthew", "michael", "nicholas", "patrick", "paul", "peter", "philip", "phillip", "ralph", "randy", "raymond", "richard", "robert", "roger", "ronald", "roy", "russell", "ryan", "samuel", "scott", "sean", "shawn", "stephen", "steve", "steven", "terry", "thomas", "timothy", "todd", "victor", "walter", "wayne", "william", "willie" ]
- Names_Female =
[ "alice", "amanda", "amy", "andrea", "angela", "ann", "anna", "anne", "annie", "ashley", "barbara", "betty", "beverly", "bonnie", "brenda", "carol", "carolyn", "catherine", "cheryl", "christina", "christine", "cynthia", "deborah", "debra", "denise", "diana", "diane", "donna", "doris", "dorothy", "elizabeth", "emily", "evelyn", "frances", "gloria", "heather", "helen", "irene", "jacqueline", "jane", "janet", "janice", "jean", "jennifer", "jessica", "joan", "joyce", "judith", "judy", "julia", "julie", "karen", "katherine", "kathleen", "kathryn", "kathy", "kelly", "kimberly", "laura", "lillian", "linda", "lisa", "lois", "lori", "louise", "margaret", "maria", "marie", "marilyn", "martha", "mary", "melissa", "michelle", "mildred", "nancy", "nicole", "norma", "pamela", "patricia", "paula", "phyllis", "rachel", "rebecca", "robin", "rose", "ruby", "ruth", "sandra", "sara", "sarah", "sharon", "shirley", "stephanie", "susan", "tammy", "teresa", "theresa", "tina", "virginia", "wanda" ]
- @@codepage_map_cache =
nil
Class Method Summary collapse
-
.ascii_safe_hex(str, whitespace = false) ⇒ Object
Turn non-printable chars into hex representations, leaving others alone.
-
.b32decode(bytes_in) ⇒ Object
Base32 decoder.
-
.b32encode(bytes_in) ⇒ Object
Base32 encoder.
-
.badchar_index(data, badchars = '') ⇒ Fixnum?
Return the index of the first badchar in
data
, otherwise return nil if there wasn’t any badchar occurences. -
.block_api_hash(mod, fun) ⇒ String
Calculate the block API hash for the given module/function.
-
.charset_exclude(keepers) ⇒ String
Returns all chars that are not in the supplied set.
-
.compress(str) ⇒ String
Compresses a string, eliminating all superfluous whitespace before and after lines and eliminating all lines.
-
.cowsay(text, width = 39) ⇒ Object
Converts a string to one similar to what would be used by cowsay(1), a UNIX utility for displaying text as if it was coming from an ASCII-cow’s mouth:.
- .decode_base32(str) ⇒ Object
-
.decode_base64(str) ⇒ Object
Base64 decoder.
-
.decode_base64url(str) ⇒ Object
Base64 decoder (URL-safe RFC6920, ignores invalid characters).
-
.dehex(str) ⇒ Object
Convert hex-encoded characters to literals.
-
.dehex!(str) ⇒ Object
Convert and replace hex-encoded characters to literals.
- .encode_base32(str) ⇒ Object
-
.encode_base64(str, delim = '') ⇒ Object
Base64 encoder.
-
.encode_base64url(str, delim = '') ⇒ Object
Base64 encoder (URL-safe RFC6920).
-
.from_ebcdic(str) ⇒ String
A native implementation of the EBCDIC to ASCII conversion table, since EBCDIC isn’t available to String#encode as of Ruby 2.1.
-
.from_ibm1047(str) ⇒ Object
The next two are the same as the above, except strictly for z/os conversions strictly for ISO8859-1 -> IBM1047 A native implementation of the ISO8859-1(ASCII) -> IBM1047(EBCDIC) conversion table, since EBCDIC isn’t available to String#encode as of Ruby 2.1.
-
.gzip(str, level = 9) ⇒ String
Compresses a string using gzip.
-
.gzip_present? ⇒ Boolean
backwards compat for just a bit…
-
.hex_to_raw(str) ⇒ Object
Converts a hex string to a raw string.
-
.hexify(str, col = DefaultWrap, line_start = '', line_end = '', buf_start = '', buf_end = '') ⇒ Object
Converts a string to a hex version with wrapping support.
-
.html_decode(str) ⇒ Object
Decode a string that’s html encoded.
-
.html_encode(str, mode = 'hex') ⇒ String
Encode a string in a manner useful for HTTP URIs and URI Parameters.
-
.md5(str) ⇒ Object
Hexidecimal MD5 digest of the supplied string.
-
.md5_raw(str) ⇒ Object
Raw MD5 digest of the supplied string.
-
.pack_int64le(val) ⇒ Object
Pack a value as 64 bit litle endian; does not exist for Array.pack.
-
.patt2(len, sets = nil) ⇒ Object
Step through an arbitrary number of sets of bytes to build up a findable pattern.
-
.pattern_create(length, sets = nil) ⇒ String
Creates a pattern that can be used for offset calculation purposes.
-
.pattern_offset(pattern, value, start = 0) ⇒ Fixnum?
Calculate the offset to a pattern.
-
.permute_case(word, idx = 0) ⇒ Object
Permute the case of a word.
-
.rand_4byte_utf8 ⇒ String
Generate a valid random 4 byte UTF-8 character valid codepoints for 4byte UTF-8 chars: U+010000 - U+10FFFF.
-
.rand_base(len, bad, *foo) ⇒ Object
Base text generator method.
-
.rand_char(bad, chars = AllChars) ⇒ Object
Generates a random character.
-
.rand_guid ⇒ String
Generate a random GUID.
-
.rand_hostname ⇒ String
Generate a random hostname.
-
.rand_mail_address ⇒ Object
Generate a random mail address.
-
.rand_name ⇒ Object
Generate a name.
-
.rand_name_female ⇒ Object
Generate a female name.
-
.rand_name_male ⇒ Object
Generate a male name.
-
.rand_state ⇒ Object
Generate a state.
-
.rand_surname ⇒ Object
Generate a surname.
-
.rand_text(len, bad = '', chars = AllChars) ⇒ Object
Generate random bytes of data.
-
.rand_text_alpha(len, bad = '') ⇒ Object
Generate random bytes of alpha data.
-
.rand_text_alpha_lower(len, bad = '') ⇒ Object
Generate random bytes of lowercase alpha data.
-
.rand_text_alpha_upper(len, bad = '') ⇒ Object
Generate random bytes of uppercase alpha data.
-
.rand_text_alphanumeric(len, bad = '') ⇒ Object
Generate random bytes of alphanumeric data.
-
.rand_text_base64(len, bad = '') ⇒ Object
Generate random bytes of base64 data.
-
.rand_text_base64url(len, bad = '') ⇒ Object
Generate random bytes of base64url data.
-
.rand_text_english(len, bad = '') ⇒ Object
Generate random bytes of english-like data.
-
.rand_text_hex(len, bad = '') ⇒ Object
Generate random bytes of alphanumeric hex.
-
.rand_text_highascii(len, bad = '') ⇒ Object
Generate random bytes of high ascii data.
-
.rand_text_numeric(len, bad = '') ⇒ Object
Generate random bytes of numeric data.
-
.randomize_space(str) ⇒ Object
Randomize the whitespace in a string.
-
.refine(str1, str2) ⇒ Object
Removes noise from 2 Strings and return a refined String version.
-
.remove_badchars(data, badchars = '') ⇒ Object
Removes bad characters from a string.
-
.rol(val, cnt) ⇒ Object
Rotate a 32-bit value to the left by
cnt
bits. -
.ror(val, cnt) ⇒ Object
Rotate a 32-bit value to the right by
cnt
bits. -
.ror13_hash(name) ⇒ Fixnum
Calculate the ROR13 hash of a given string.
-
.sha1(str) ⇒ Object
Hexidecimal SHA1 digest of the supplied string.
-
.sha1_raw(str) ⇒ Object
Raw SHA1 digest of the supplied string.
-
.shuffle_a(arr) ⇒ Array
Performs a Fisher-Yates shuffle on an array.
-
.shuffle_s(str) ⇒ String
Shuffles a byte stream.
-
.split_to_a(str, n) ⇒ Object
Split a string by n character into an array.
-
.to_ascii(str = '', type = 'utf-16le', mode = '', size = '') ⇒ Object
Converts a unicode string to standard ASCII text.
-
.to_bash(str, wrap = DefaultWrap, name = "buf") ⇒ Object
Converts a raw string into a Bash buffer.
-
.to_bash_comment(str, wrap = DefaultWrap) ⇒ Object
Creates a Bash-style comment.
-
.to_c(str, wrap = DefaultWrap, name = "buf") ⇒ Object
Converts a raw string into a C buffer.
-
.to_c_comment(str, wrap = DefaultWrap) ⇒ Object
Creates a c-style comment.
- .to_csharp(str, wrap = DefaultWrap, name = "buf") ⇒ Object
-
.to_dword(str, wrap = DefaultWrap) ⇒ Object
Creates a comma separated list of dwords.
-
.to_ebcdic(str) ⇒ String
A native implementation of the ASCII to EBCDIC conversion table, since EBCDIC isn’t available to String#encode as of Ruby 2.1.
-
.to_guid(bytes) ⇒ String
Convert 16-byte string to a GUID string.
-
.to_hex(str, prefix = "\\x", count = 1) ⇒ String
Returns the escaped hex version of the supplied string.
-
.to_hex_ascii(str, prefix = "\\x", count = 1, suffix = nil) ⇒ String
Returns the string with nonprintable hex characters sanitized to ascii.
-
.to_hex_dump(str, width = 16, base = nil) ⇒ Object
Converts a string to a nicely formatted hex dump.
-
.to_ibm1047(str) ⇒ Object
The next two are the same as the above, except strictly for z/os conversions strictly for IBM1047 -> ISO8859-1 A native implementation of the IBM1047(EBCDIC) -> ISO8859-1(ASCII) conversion table, since EBCDIC isn’t available to String#encode as of Ruby 2.1 all 256 bytes are defined.
-
.to_java(str, name = "shell") ⇒ Object
Converts a raw string into a java byte array.
-
.to_js_comment(str, wrap = DefaultWrap) ⇒ Object
Creates a javascript-style comment.
-
.to_mixed_case_array(str) ⇒ Array<String>
Takes a string, and returns an array of all mixed case versions.
-
.to_num(str, wrap = DefaultWrap) ⇒ Object
Creates a comma separated list of numbers.
-
.to_octal(str, prefix = "\\") ⇒ String
Returns the escaped octal version of the supplied string.
-
.to_perl(str, wrap = DefaultWrap, name = "buf") ⇒ Object
Converts a raw string into a perl buffer.
-
.to_perl_comment(str, wrap = DefaultWrap) ⇒ Object
Creates a perl-style comment.
-
.to_powershell(str, name = "buf") ⇒ Object
Converts a raw string to a powershell byte array.
-
.to_python(str, wrap = DefaultWrap, name = "buf") ⇒ Object
Converts a raw string into a python buffer.
-
.to_rand_case(str) ⇒ String
Converts a string to random case.
-
.to_raw(str) ⇒ Object
Returns the raw string.
-
.to_ruby(str, wrap = DefaultWrap, name = "buf") ⇒ Object
Converts a raw string into a ruby buffer.
-
.to_ruby_comment(str, wrap = DefaultWrap) ⇒ Object
Creates a ruby-style comment.
-
.to_unescape(data, endian = ENDIAN_LITTLE, prefix = '%%u') ⇒ Object
Returns a unicode escaped string for Javascript.
-
.to_unicode(str = '', type = 'utf-16le', mode = '', size = '') ⇒ Object
Converts standard ASCII text to a unicode string.
-
.to_utf8(str) ⇒ String
Converts US-ASCII to UTF-8, skipping over any characters which don’t convert cleanly.
-
.to_vbapplication(str, name = "buf") ⇒ Object
Converts a raw string into a vba buffer.
-
.to_vbscript(str, name = "buf") ⇒ Object
Converts a raw string to a vbscript byte array.
-
.to_words(str, strict = false) ⇒ Object
Returns the words in
str
as an Array. -
.ungzip(str) ⇒ String
Uncompresses a string using gzip.
- .unicode_filter_decode(str) ⇒ Object
-
.unicode_filter_encode(str) ⇒ Object
A custom unicode filter for dealing with multi-byte strings on a 8-bit console Punycode would have been more “standard”, but it requires valid Unicode chars.
-
.uri_decode(str) ⇒ Object
Decode a URI encoded string.
-
.uri_encode(str, mode = 'hex-normal') ⇒ Object
Encode a string in a manor useful for HTTP URIs and URI Parameters.
-
.wordwrap(str, indent = 0, col = DefaultWrap, append = '', prepend = '') ⇒ Object
Wraps text at a given column using a supplied indention.
-
.xml_char_encode(str) ⇒ Object
Encode an ASCII string so it’s safe for XML.
-
.zlib_deflate(str, level = Zlib::BEST_COMPRESSION) ⇒ String
Compresses a string using zlib.
-
.zlib_inflate(str) ⇒ String
Uncompresses a string using zlib.
-
.zlib_present? ⇒ Boolean
Returns true if zlib can be used.
Class Method Details
.ascii_safe_hex(str, whitespace = false) ⇒ Object
Turn non-printable chars into hex representations, leaving others alone
If whitespace
is true, converts whitespace (0x20, 0x09, etc) to hex as well.
1062 1063 1064 1065 1066 1067 1068 |
# File 'lib/rex/text.rb', line 1062 def self.ascii_safe_hex(str, whitespace=false) if whitespace str.gsub(/([\x00-\x20\x80-\xFF])/n){ |x| "\\x%.2x" % x.unpack("C*")[0] } else str.gsub(/([\x00-\x08\x0b\x0c\x0e-\x1f\x80-\xFF])/n){ |x| "\\x%.2x" % x.unpack("C*")[0]} end end |
.b32decode(bytes_in) ⇒ Object
Base32 decoder
1240 1241 1242 1243 1244 1245 1246 |
# File 'lib/rex/text.rb', line 1240 def self.b32decode(bytes_in) bytes = bytes_in.take_while {|c| c != 61} # strip padding n = (bytes.length * 5.0 / 8.0).floor p = bytes.length < 8 ? 5 - (n * 8) % 5 : 0 c = bytes.inject(0) {|m,o| (m << 5) + Base32.index(o.chr)} >> p (0..n-1).to_a.reverse.collect {|i| ((c >> i * 8) & 0xff).chr} end |
.b32encode(bytes_in) ⇒ Object
Base32 encoder
1215 1216 1217 1218 1219 1220 1221 |
# File 'lib/rex/text.rb', line 1215 def self.b32encode(bytes_in) n = (bytes_in.length * 8.0 / 5.0).ceil p = n < 8 ? 5 - (bytes_in.length * 8) % 5 : 0 c = bytes_in.inject(0) {|m,o| (m << 8) + o} << p [(0..n-1).to_a.reverse.collect {|i| Base32[(c >> i * 5) & 0x1f].chr}, ("=" * (8-n))] end |
.badchar_index(data, badchars = '') ⇒ Fixnum?
Return the index of the first badchar in data
, otherwise return nil if there wasn’t any badchar occurences.
1691 1692 1693 1694 1695 1696 1697 |
# File 'lib/rex/text.rb', line 1691 def self.badchar_index(data, badchars = '') badchars.unpack("C*").each { |badchar| pos = data.index(badchar.chr) return pos if pos } return nil end |
.block_api_hash(mod, fun) ⇒ String
Calculate the block API hash for the given module/function
1838 1839 1840 1841 1842 1843 |
# File 'lib/rex/text.rb', line 1838 def self.block_api_hash(mod, fun) unicode_mod = (mod.upcase + "\x00").unpack('C*').pack('v*') mod_hash = self.ror13_hash(unicode_mod) fun_hash = self.ror13_hash(fun + "\x00") "0x#{(mod_hash + fun_hash & 0xFFFFFFFF).to_s(16)}" end |
.charset_exclude(keepers) ⇒ String
Returns all chars that are not in the supplied set
1718 1719 1720 1721 |
# File 'lib/rex/text.rb', line 1718 def self.charset_exclude(keepers) excluded_bytes = [*(0..255)] - keepers.unpack("C*") excluded_bytes.pack("C*") end |
.compress(str) ⇒ String
Compresses a string, eliminating all superfluous whitespace before and after lines and eliminating all lines.
1580 1581 1582 |
# File 'lib/rex/text.rb', line 1580 def self.compress(str) str.gsub(/\n/m, ' ').gsub(/\s+/, ' ').gsub(/^\s+/, '').gsub(/\s+$/, '') end |
.cowsay(text, width = 39) ⇒ Object
Converts a string to one similar to what would be used by cowsay(1), a UNIX utility for displaying text as if it was coming from an ASCII-cow’s mouth:
__________________
< the cow says moo >
------------------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 |
# File 'lib/rex/text.rb', line 1144 def self.cowsay(text, width=39) # cowsay(1) chunks a message up into 39-byte chunks and wraps it in '| ' and ' |' # Rex::Text.wordwrap(text, 0, 39, ' |', '| ') almost does this, but won't # split a word that has > 39 characters in it which results in oddly formed # text in the cowsay banner, so just do it by hand. This big mess wraps # the provided text in an ASCII-cloud and then makes it look like the cloud # is a thought/word coming from the ASCII-cow. Each line in the # ASCII-cloud is no more than the specified number-characters long, and the # cloud corners are made to look rounded text_lines = text.scan(Regexp.new(".{1,#{width-4}}")) max_length = text_lines.map(&:size).sort.last cloud_parts = [] cloud_parts << " #{'_' * (max_length + 2)}" if text_lines.size == 1 cloud_parts << "< #{text} >" else cloud_parts << "/ #{text_lines.first.ljust(max_length, ' ')} \\" if text_lines.size > 2 text_lines[1, text_lines.length - 2].each do |line| cloud_parts << "| #{line.ljust(max_length, ' ')} |" end end cloud_parts << "\\ #{text_lines.last.ljust(max_length, ' ')} /" end cloud_parts << " #{'-' * (max_length + 2)}" cloud_parts << <<EOS \\ ,__, \\ (oo)____ (__) )\\ ||--|| * EOS cloud_parts.join("\n") end |
.decode_base32(str) ⇒ Object
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 |
# File 'lib/rex/text.rb', line 1248 def self.decode_base32(str) bytes = str.bytes result = '' size= 8 while bytes.any? do bytes.each_slice(size) do |a| bytes_out = b32decode(a).flatten.join result << bytes_out bytes = bytes.drop(size) end end return result end |
.decode_base64(str) ⇒ Object
Base64 decoder
1272 1273 1274 |
# File 'lib/rex/text.rb', line 1272 def self.decode_base64(str) str.to_s.unpack("m")[0] end |
.decode_base64url(str) ⇒ Object
Base64 decoder (URL-safe RFC6920, ignores invalid characters)
1288 1289 1290 1291 1292 |
# File 'lib/rex/text.rb', line 1288 def self.decode_base64url(str) decode_base64( str.gsub(/[^a-zA-Z0-9_\-]/, ''). tr('-_', '+/')) end |
.dehex(str) ⇒ Object
Convert hex-encoded characters to literals.
1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 |
# File 'lib/rex/text.rb', line 1330 def self.dehex(str) return str unless str.respond_to? :match return str unless str.respond_to? :gsub regex = /\x5cx[0-9a-f]{2}/nmi if str.match(regex) str.gsub(regex) { |x| x[2,2].to_i(16).chr } else str end end |
.dehex!(str) ⇒ Object
Convert and replace hex-encoded characters to literals.
1345 1346 1347 1348 1349 1350 |
# File 'lib/rex/text.rb', line 1345 def self.dehex!(str) return str unless str.respond_to? :match return str unless str.respond_to? :gsub regex = /\x5cx[0-9a-f]{2}/nmi str.gsub!(regex) { |x| x[2,2].to_i(16).chr } end |
.encode_base32(str) ⇒ Object
1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 |
# File 'lib/rex/text.rb', line 1223 def self.encode_base32(str) bytes = str.bytes result = '' size= 5 while bytes.any? do bytes.each_slice(size) do |a| bytes_out = b32encode(a).flatten.join result << bytes_out bytes = bytes.drop(size) end end return result end |
.encode_base64(str, delim = '') ⇒ Object
Base64 encoder
1265 1266 1267 |
# File 'lib/rex/text.rb', line 1265 def self.encode_base64(str, delim='') [str.to_s].pack("m").gsub(/\s+/, delim) end |
.encode_base64url(str, delim = '') ⇒ Object
Base64 encoder (URL-safe RFC6920)
1279 1280 1281 1282 1283 |
# File 'lib/rex/text.rb', line 1279 def self.encode_base64url(str, delim='') encode_base64(str, delim). tr('+/', '-_'). gsub('=', '') end |
.from_ebcdic(str) ⇒ String
This method will raise in the event of invalid characters
A native implementation of the EBCDIC to ASCII conversion table, since EBCDIC isn’t available to String#encode as of Ruby 2.1
492 493 494 495 496 497 498 499 500 501 502 |
# File 'lib/rex/text.rb', line 492 def self.from_ebcdic(str) new_str = [] str.each_byte do |x| if Iconv_EBCDIC.index(x.chr) new_str << Iconv_ASCII[Iconv_EBCDIC.index(x.chr)] else raise Rex::Text::IllegalSequence, ("\\x%x" % x) end end new_str.join end |
.from_ibm1047(str) ⇒ Object
The next two are the same as the above, except strictly for z/os conversions
strictly for ISO8859-1 -> IBM1047
A native implementation of the ISO8859-1(ASCII) -> IBM1047(EBCDIC) conversion table, since EBCDIC isn’t available to String#encode as of Ruby 2.1
528 529 530 531 532 533 534 535 |
# File 'lib/rex/text.rb', line 528 def self.from_ibm1047(str) return str if str.nil? new_str = [] str.each_byte do |x| new_str << Iconv_ISO8859_1[x.ord] end new_str.join end |
.gzip(str, level = 9) ⇒ String
Compresses a string using gzip
1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 |
# File 'lib/rex/text.rb', line 1655 def self.gzip(str, level = 9) raise RuntimeError, "Gzip support is not present." if (!zlib_present?) raise RuntimeError, "Invalid gzip compression level" if (level < 1 or level > 9) s = "" s.force_encoding('ASCII-8BIT') if s.respond_to?(:encoding) gz = Zlib::GzipWriter.new(StringIO.new(s, 'wb'), level) gz << str gz.close return s end |
.gzip_present? ⇒ Boolean
backwards compat for just a bit…
1611 1612 1613 |
# File 'lib/rex/text.rb', line 1611 def self.gzip_present? self.zlib_present? end |
.hex_to_raw(str) ⇒ Object
Converts a hex string to a raw string
1049 1050 1051 |
# File 'lib/rex/text.rb', line 1049 def self.hex_to_raw(str) [ str.downcase.gsub(/'/,'').gsub(/\\?x([a-f0-9][a-f0-9])/, '\1') ].pack("H*") end |
.hexify(str, col = DefaultWrap, line_start = '', line_end = '', buf_start = '', buf_end = '') ⇒ Object
Converts a string to a hex version with wrapping support
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 |
# File 'lib/rex/text.rb', line 1081 def self.hexify(str, col = DefaultWrap, line_start = '', line_end = '', buf_start = '', buf_end = '') output = buf_start cur = 0 count = 0 new_line = true # Go through each byte in the string str.each_byte { |byte| count += 1 append = '' # If this is a new line, prepend with the # line start text if (new_line == true) append << line_start new_line = false end # Append the hexified version of the byte append << sprintf("\\x%.2x", byte) cur += append.length # If we're about to hit the column or have gone past it, # time to finish up this line if ((cur + line_end.length >= col) or (cur + buf_end.length >= col)) new_line = true cur = 0 # If this is the last byte, use the buf_end instead of # line_end if (count == str.length) append << buf_end + "\n" else append << line_end + "\n" end end output << append } # If we were in the middle of a line, finish the buffer at this point if (new_line == false) output << buf_end + "\n" end return output end |
.html_decode(str) ⇒ Object
Decode a string that’s html encoded
935 936 937 938 |
# File 'lib/rex/text.rb', line 935 def self.html_decode(str) decoded_str = CGI.unescapeHTML(str) return decoded_str end |
.html_encode(str, mode = 'hex') ⇒ String
Encode a string in a manner useful for HTTP URIs and URI Parameters.
919 920 921 922 923 924 925 926 927 928 929 930 |
# File 'lib/rex/text.rb', line 919 def self.html_encode(str, mode = 'hex') case mode when 'hex' return str.unpack('C*').collect{ |i| "&#x" + ("%.2x" % i) + ";"}.join when 'int' return str.unpack('C*').collect{ |i| "&#" + i.to_s + ";"}.join when 'int-wide' return str.unpack('C*').collect{ |i| "&#" + ("0" * (7 - i.to_s.length)) + i.to_s + ";" }.join else raise TypeError, 'invalid mode' end end |
.md5(str) ⇒ Object
Hexidecimal MD5 digest of the supplied string
1304 1305 1306 |
# File 'lib/rex/text.rb', line 1304 def self.md5(str) Digest::MD5.hexdigest(str) end |
.md5_raw(str) ⇒ Object
Raw MD5 digest of the supplied string
1297 1298 1299 |
# File 'lib/rex/text.rb', line 1297 def self.md5_raw(str) Digest::MD5.digest(str) end |
.pack_int64le(val) ⇒ Object
Pack a value as 64 bit litle endian; does not exist for Array.pack
1900 1901 1902 |
# File 'lib/rex/text.rb', line 1900 def self.pack_int64le(val) [val & 0x00000000ffffffff, val >> 32].pack("V2") end |
.patt2(len, sets = nil) ⇒ Object
Step through an arbitrary number of sets of bytes to build up a findable pattern. This is mostly useful for experimentially determining offset lengths into memory structures. Note that the supplied sets should never contain duplicate bytes, or else it can become impossible to measure the offset accurately.
1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 |
# File 'lib/rex/text.rb', line 1536 def self.patt2(len, sets = nil) buf = "" counter = [] sets ||= [ UpperAlpha, LowerAlpha, Numerals ] len ||= len.to_i return "" if len.zero? sets = sets.map {|a| a.split(//)} sets.size.times { counter << 0} 0.upto(len-1) do |i| setnum = i % sets.size #puts counter.inspect end return buf end |
.pattern_create(length, sets = nil) ⇒ String
Creates a pattern that can be used for offset calculation purposes. This routine is capable of generating patterns using a supplied set and a supplied number of identifiable characters (slots). The supplied sets should not contain any duplicate characters or the logic will fail.
1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 |
# File 'lib/rex/text.rb', line 1505 def self.pattern_create(length, sets = nil) buf = '' offsets = [] # Make sure there's something in sets even if we were given an explicit nil sets ||= [ UpperAlpha, LowerAlpha, Numerals ] # Return stupid uses return "" if length.to_i < 1 return sets[0][0].chr * length if sets.size == 1 and sets[0].size == 1 sets.length.times { offsets << 0 } until buf.length >= length begin buf << converge_sets(sets, 0, offsets, length) end end # Maximum permutations reached, but we need more data if (buf.length < length) buf = buf * (length / buf.length.to_f).ceil end buf[0,length] end |
.pattern_offset(pattern, value, start = 0) ⇒ Fixnum?
Calculate the offset to a pattern
1563 1564 1565 1566 1567 1568 1569 1570 1571 |
# File 'lib/rex/text.rb', line 1563 def self.pattern_offset(pattern, value, start=0) if (value.kind_of?(String)) pattern.index(value, start) elsif (value.kind_of?(Fixnum) or value.kind_of?(Bignum)) pattern.index([ value ].pack('V'), start) else raise ::ArgumentError, "Invalid class for value: #{value.class}" end end |
.permute_case(word, idx = 0) ⇒ Object
Permute the case of a word
1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 |
# File 'lib/rex/text.rb', line 1756 def self.permute_case(word, idx=0) res = [] if( (UpperAlpha+LowerAlpha).index(word[idx,1])) word_ucase = word.dup word_ucase[idx, 1] = word[idx, 1].upcase word_lcase = word.dup word_lcase[idx, 1] = word[idx, 1].downcase if (idx == word.length) return [word] else res << permute_case(word_ucase, idx+1) res << permute_case(word_lcase, idx+1) end else res << permute_case(word, idx+1) end res.flatten end |
.rand_4byte_utf8 ⇒ String
Generate a valid random 4 byte UTF-8 character valid codepoints for 4byte UTF-8 chars: U+010000 - U+10FFFF
1488 1489 1490 |
# File 'lib/rex/text.rb', line 1488 def self.rand_4byte_utf8 [rand(0x10000..0x10ffff)].pack('U*') end |
.rand_base(len, bad, *foo) ⇒ Object
Base text generator method
1365 1366 1367 1368 1369 1370 1371 |
# File 'lib/rex/text.rb', line 1365 def self.rand_base(len, bad, *foo) cset = (foo.join.unpack("C*") - bad.to_s.unpack("C*")).uniq return "" if cset.length == 0 outp = [] len.times { outp << cset[rand(cset.length)] } outp.pack("C*") end |
.rand_char(bad, chars = AllChars) ⇒ Object
Generates a random character.
1360 1361 1362 |
# File 'lib/rex/text.rb', line 1360 def self.rand_char(bad, chars = AllChars) rand_text(1, bad, chars) end |
.rand_guid ⇒ String
Generate a random GUID
1452 1453 1454 |
# File 'lib/rex/text.rb', line 1452 def self.rand_guid "{#{[8,4,4,4,12].map {|a| rand_text_hex(a) }.join("-")}}" end |
.rand_hostname ⇒ String
Generate a random hostname
1783 1784 1785 1786 1787 1788 1789 1790 |
# File 'lib/rex/text.rb', line 1783 def self.rand_hostname host = [] (rand(5) + 1).times { host.push(Rex::Text.rand_text_alphanumeric(rand(10) + 1)) } host.push(TLDs.sample) host.join('.').downcase end |
.rand_mail_address ⇒ Object
Generate a random mail address
1822 1823 1824 1825 1826 1827 1828 1829 |
# File 'lib/rex/text.rb', line 1822 def self.rand_mail_address mail_address = '' mail_address << Rex::Text.rand_name mail_address << '.' mail_address << Rex::Text.rand_surname mail_address << '@' mail_address << Rex::Text.rand_hostname end |
.rand_name ⇒ Object
Generate a name
1803 1804 1805 1806 1807 1808 1809 |
# File 'lib/rex/text.rb', line 1803 def self.rand_name if rand(10) % 2 == 0 Names_Male.sample else Names_Female.sample end end |
.rand_name_female ⇒ Object
Generate a female name
1817 1818 1819 |
# File 'lib/rex/text.rb', line 1817 def self.rand_name_female Names_Female.sample end |
.rand_name_male ⇒ Object
Generate a male name
1812 1813 1814 |
# File 'lib/rex/text.rb', line 1812 def self.rand_name_male Names_Male.sample end |
.rand_state ⇒ Object
Generate a state
1793 1794 1795 |
# File 'lib/rex/text.rb', line 1793 def self.rand_state() States.sample end |
.rand_surname ⇒ Object
Generate a surname
1798 1799 1800 |
# File 'lib/rex/text.rb', line 1798 def self.rand_surname Surnames.sample end |
.rand_text(len, bad = '', chars = AllChars) ⇒ Object
Generate random bytes of data
1374 1375 1376 1377 |
# File 'lib/rex/text.rb', line 1374 def self.rand_text(len, bad='', chars = AllChars) foo = chars.split('') rand_base(len, bad, *foo) end |
.rand_text_alpha(len, bad = '') ⇒ Object
Generate random bytes of alpha data
1380 1381 1382 1383 1384 1385 |
# File 'lib/rex/text.rb', line 1380 def self.rand_text_alpha(len, bad='') foo = [] foo += ('A' .. 'Z').to_a foo += ('a' .. 'z').to_a rand_base(len, bad, *foo ) end |
.rand_text_alpha_lower(len, bad = '') ⇒ Object
Generate random bytes of lowercase alpha data
1388 1389 1390 |
# File 'lib/rex/text.rb', line 1388 def self.rand_text_alpha_lower(len, bad='') rand_base(len, bad, *('a' .. 'z').to_a) end |
.rand_text_alpha_upper(len, bad = '') ⇒ Object
Generate random bytes of uppercase alpha data
1393 1394 1395 |
# File 'lib/rex/text.rb', line 1393 def self.rand_text_alpha_upper(len, bad='') rand_base(len, bad, *('A' .. 'Z').to_a) end |
.rand_text_alphanumeric(len, bad = '') ⇒ Object
Generate random bytes of alphanumeric data
1398 1399 1400 1401 1402 1403 1404 |
# File 'lib/rex/text.rb', line 1398 def self.rand_text_alphanumeric(len, bad='') foo = [] foo += ('A' .. 'Z').to_a foo += ('a' .. 'z').to_a foo += ('0' .. '9').to_a rand_base(len, bad, *foo ) end |
.rand_text_base64(len, bad = '') ⇒ Object
Generate random bytes of base64 data
1435 1436 1437 1438 |
# File 'lib/rex/text.rb', line 1435 def self.rand_text_base64(len, bad='') foo = Base64.unpack('C*').map{ |c| c.chr } rand_base(len, bad, *foo ) end |
.rand_text_base64url(len, bad = '') ⇒ Object
Generate random bytes of base64url data
1441 1442 1443 1444 |
# File 'lib/rex/text.rb', line 1441 def self.rand_text_base64url(len, bad='') foo = Base64Url.unpack('C*').map{ |c| c.chr } rand_base(len, bad, *foo ) end |
.rand_text_english(len, bad = '') ⇒ Object
Generate random bytes of english-like data
1421 1422 1423 1424 1425 |
# File 'lib/rex/text.rb', line 1421 def self.rand_text_english(len, bad='') foo = [] foo += (0x21 .. 0x7e).map{ |c| c.chr } rand_base(len, bad, *foo ) end |
.rand_text_hex(len, bad = '') ⇒ Object
Generate random bytes of alphanumeric hex.
1407 1408 1409 1410 1411 1412 |
# File 'lib/rex/text.rb', line 1407 def self.rand_text_hex(len, bad='') foo = [] foo += ('0' .. '9').to_a foo += ('a' .. 'f').to_a rand_base(len, bad, *foo) end |
.rand_text_highascii(len, bad = '') ⇒ Object
Generate random bytes of high ascii data
1428 1429 1430 1431 1432 |
# File 'lib/rex/text.rb', line 1428 def self.rand_text_highascii(len, bad='') foo = [] foo += (0x80 .. 0xff).map{ |c| c.chr } rand_base(len, bad, *foo ) end |
.rand_text_numeric(len, bad = '') ⇒ Object
Generate random bytes of numeric data
1415 1416 1417 1418 |
# File 'lib/rex/text.rb', line 1415 def self.rand_text_numeric(len, bad='') foo = ('0' .. '9').to_a rand_base(len, bad, *foo ) end |
.randomize_space(str) ⇒ Object
Randomize the whitespace in a string
1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 |
# File 'lib/rex/text.rb', line 1587 def self.randomize_space(str) set = ["\x09", "\x20", "\x0d", "\x0a"] str.gsub(/\s+/) { |s| len = rand(50)+2 buf = '' while (buf.length < len) buf << set.sample end buf } end |
.refine(str1, str2) ⇒ Object
Removes noise from 2 Strings and return a refined String version.
551 552 553 554 555 556 557 558 559 560 561 562 |
# File 'lib/rex/text.rb', line 551 def self.refine( str1, str2 ) return str1 if str1 == str2 # get the words of the first str in an array s_words = to_words( str1 ) # get the words of the second str in an array o_words = to_words( str2 ) # get what hasn't changed (the rdiff, so to speak) as a string (s_words - (s_words - o_words)).join end |
.remove_badchars(data, badchars = '') ⇒ Object
Removes bad characters from a string.
Modifies data
in place
1706 1707 1708 1709 1710 1711 |
# File 'lib/rex/text.rb', line 1706 def self.remove_badchars(data, badchars = '') return data if badchars.length == 0 badchars_pat = badchars.unpack("C*").map{|c| "\\x%.2x" % c}.join data.gsub!(/[#{badchars_pat}]/n, '') data end |
.rol(val, cnt) ⇒ Object
Rotate a 32-bit value to the left by cnt
bits
1874 1875 1876 1877 1878 1879 1880 |
# File 'lib/rex/text.rb', line 1874 def self.rol(val, cnt) bits = [val].pack("N").unpack("B32")[0].split(//) 1.upto(cnt) do |c| bits.push( bits.shift ) end [bits.join].pack("B32").unpack("N")[0] end |
.ror(val, cnt) ⇒ Object
Rotate a 32-bit value to the right by cnt
bits
1860 1861 1862 1863 1864 1865 1866 |
# File 'lib/rex/text.rb', line 1860 def self.ror(val, cnt) bits = [val].pack("N").unpack("B32")[0].split(//) 1.upto(cnt) do |c| bits.unshift( bits.pop ) end [bits.join].pack("B32").unpack("N")[0] end |
.ror13_hash(name) ⇒ Fixnum
Calculate the ROR13 hash of a given string
1849 1850 1851 1852 1853 |
# File 'lib/rex/text.rb', line 1849 def self.ror13_hash(name) hash = 0 name.unpack("C*").each {|c| hash = ror(hash, 13); hash += c } hash end |
.sha1(str) ⇒ Object
Hexidecimal SHA1 digest of the supplied string
1318 1319 1320 |
# File 'lib/rex/text.rb', line 1318 def self.sha1(str) Digest::SHA1.hexdigest(str) end |
.sha1_raw(str) ⇒ Object
Raw SHA1 digest of the supplied string
1311 1312 1313 |
# File 'lib/rex/text.rb', line 1311 def self.sha1_raw(str) Digest::SHA1.digest(str) end |
.shuffle_a(arr) ⇒ Array
Performs a Fisher-Yates shuffle on an array
Modifies arr
in place
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 |
# File 'lib/rex/text.rb', line 1740 def self.shuffle_a(arr) len = arr.length max = len - 1 cyc = [* (0..max) ] for d in cyc e = rand(d+1) next if e == d f = arr[d]; g = arr[e]; arr[d] = g; arr[e] = f; end return arr end |
.shuffle_s(str) ⇒ String
Shuffles a byte stream
1729 1730 1731 |
# File 'lib/rex/text.rb', line 1729 def self.shuffle_s(str) shuffle_a(str.unpack("C*")).pack("C*") end |
.split_to_a(str, n) ⇒ Object
Split a string by n character into an array
1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 |
# File 'lib/rex/text.rb', line 1885 def self.split_to_a(str, n) if n > 0 s = str.dup until s.empty? (ret ||= []).push s.slice!(0, n) end else ret = str end ret end |
.to_ascii(str = '', type = 'utf-16le', mode = '', size = '') ⇒ Object
Converts a unicode string to standard ASCII text.
837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 |
# File 'lib/rex/text.rb', line 837 def self.to_ascii(str='', type = 'utf-16le', mode = '', size = '') return '' if not str case type when 'utf-16le' return str.unpack('v*').pack('C*') when 'utf-16be' return str.unpack('n*').pack('C*') when 'utf-32le' return str.unpack('V*').pack('C*') when 'utf-32be' return str.unpack('N*').pack('C*') when 'utf-7' raise TypeError, 'invalid utf type, not yet implemented' when 'utf-8' raise TypeError, 'invalid utf type, not yet implemented' when 'uhwtfms' # suggested name from HD :P raise TypeError, 'invalid utf type, not yet implemented' when 'uhwtfms-half' # suggested name from HD :P raise TypeError, 'invalid utf type, not yet implemented' else raise TypeError, 'invalid utf type' end end |
.to_bash(str, wrap = DefaultWrap, name = "buf") ⇒ Object
Converts a raw string into a Bash buffer
358 359 360 |
# File 'lib/rex/text.rb', line 358 def self.to_bash(str, wrap = DefaultWrap, name = "buf") return hexify(str, wrap, '$\'', '\'\\', "export #{name}=\\\n", '\'') end |
.to_bash_comment(str, wrap = DefaultWrap) ⇒ Object
Creates a Bash-style comment
444 445 446 |
# File 'lib/rex/text.rb', line 444 def self.to_bash_comment(str, wrap = DefaultWrap) return wordwrap(str, 0, wrap, '', '# ') end |
.to_c(str, wrap = DefaultWrap, name = "buf") ⇒ Object
Converts a raw string into a C buffer
312 313 314 |
# File 'lib/rex/text.rb', line 312 def self.to_c(str, wrap = DefaultWrap, name = "buf") return hexify(str, wrap, '"', '"', "unsigned char #{name}[] = \n", '";') end |
.to_c_comment(str, wrap = DefaultWrap) ⇒ Object
Creates a c-style comment
330 331 332 |
# File 'lib/rex/text.rb', line 330 def self.to_c_comment(str, wrap = DefaultWrap) return "/*\n" + wordwrap(str, 0, wrap, '', ' * ') + " */\n" end |
.to_csharp(str, wrap = DefaultWrap, name = "buf") ⇒ Object
316 317 318 319 320 321 322 323 324 325 |
# File 'lib/rex/text.rb', line 316 def self.to_csharp(str, wrap = DefaultWrap, name = "buf") ret = "byte[] #{name} = new byte[#{str.length}] {" i = -1; while (i += 1) < str.length ret << "\n" if i%(wrap/4) == 0 ret << "0x" << str[i].unpack("H*")[0] << "," end ret = ret[0..ret.length-2] #cut off last comma ret << " };\n" end |
.to_dword(str, wrap = DefaultWrap) ⇒ Object
Creates a comma separated list of dwords
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 |
# File 'lib/rex/text.rb', line 277 def self.to_dword(str, wrap = DefaultWrap) code = str alignnr = str.length % 4 if (alignnr > 0) code << "\x00" * (4 - alignnr) end codevalues = Array.new code.split("").each_slice(4) do |chars4| chars4 = chars4.join("") dwordvalue = chars4.unpack('*V') codevalues.push(dwordvalue[0]) end buff = "" 0.upto(codevalues.length-1) do |byte| if(byte % 8 == 0) and (buff.length > 0) buff << "\r\n" end buff << sprintf('0x%.8x, ', codevalues[byte]) end # strip , at the end buff = buff.chomp(', ') buff << "\r\n" return buff end |
.to_ebcdic(str) ⇒ String
This method will raise in the event of invalid characters
A native implementation of the ASCII to EBCDIC conversion table, since EBCDIC isn’t available to String#encode as of Ruby 2.1
474 475 476 477 478 479 480 481 482 483 484 |
# File 'lib/rex/text.rb', line 474 def self.to_ebcdic(str) new_str = [] str.each_byte do |x| if Iconv_ASCII.index(x.chr) new_str << Iconv_EBCDIC[Iconv_ASCII.index(x.chr)] else raise Rex::Text::IllegalSequence, ("\\x%x" % x) end end new_str.join end |
.to_guid(bytes) ⇒ String
Convert 16-byte string to a GUID string
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 |
# File 'lib/rex/text.rb', line 1467 def self.to_guid(bytes) return nil unless bytes s = bytes.unpack('H*')[0] parts = [ s[6, 2] + s[4, 2] + s[2, 2] + s[0, 2], s[10, 2] + s[8, 2], s[14, 2] + s[12, 2], s[16, 4], s[20, 12] ] "{#{parts.join('-')}}" end |
.to_hex(str, prefix = "\\x", count = 1) ⇒ String
Returns the escaped hex version of the supplied string
614 615 616 617 618 619 620 621 622 |
# File 'lib/rex/text.rb', line 614 def self.to_hex(str, prefix = "\\x", count = 1) raise ::RuntimeError, "unable to chunk into #{count} byte chunks" if ((str.length % count) > 0) # XXX: Regexp.new is used here since using /.{#{count}}/o would compile # the regex the first time it is used and never check again. Since we # want to know how many to capture on every instance, we do it this # way. return str.unpack('H*')[0].gsub(Regexp.new(".{#{count * 2}}", nil, 'n')) { |s| prefix + s } end |
.to_hex_ascii(str, prefix = "\\x", count = 1, suffix = nil) ⇒ String
Returns the string with nonprintable hex characters sanitized to ascii. Similiar to to_hex, but regular ASCII is not translated if count
is 1.
637 638 639 640 641 642 |
# File 'lib/rex/text.rb', line 637 def self.to_hex_ascii(str, prefix = "\\x", count = 1, suffix=nil) raise ::RuntimeError, "unable to chunk into #{count} byte chunks" if ((str.length % count) > 0) return str.unpack('H*')[0].gsub(Regexp.new(".{#{count * 2}}", nil, 'n')) { |s| (0x20..0x7e) === s.to_i(16) ? s.to_i(16).chr : prefix + s + suffix.to_s } end |
.to_hex_dump(str, width = 16, base = nil) ⇒ Object
Converts a string to a nicely formatted hex dump
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 |
# File 'lib/rex/text.rb', line 1003 def self.to_hex_dump(str, width=16, base=nil) buf = '' idx = 0 cnt = 0 snl = false lst = 0 lft_col_len = (base.to_i+str.length).to_s(16).length lft_col_len = 8 if lft_col_len < 8 while (idx < str.length) chunk = str[idx, width] addr = base ? "%0#{lft_col_len}x " %(base.to_i + idx) : '' line = chunk.unpack("H*")[0].scan(/../).join(" ") buf << addr + line if (lst == 0) lst = line.length buf << " " * 4 else buf << " " * ((lst - line.length) + 4).abs end buf << "|" chunk.unpack("C*").each do |c| if (c > 0x1f and c < 0x7f) buf << c.chr else buf << "." end end buf << "|\n" idx += width end buf << "\n" end |
.to_ibm1047(str) ⇒ Object
The next two are the same as the above, except strictly for z/os conversions
strictly for IBM1047 -> ISO8859-1
A native implementation of the IBM1047(EBCDIC) -> ISO8859-1(ASCII) conversion table, since EBCDIC isn’t available to String#encode as of Ruby 2.1 all 256 bytes are defined
512 513 514 515 516 517 518 519 |
# File 'lib/rex/text.rb', line 512 def self.to_ibm1047(str) return str if str.nil? new_str = [] str.each_byte do |x| new_str << Iconv_IBM1047[x.ord] end new_str.join end |
.to_java(str, name = "shell") ⇒ Object
Converts a raw string into a java byte array
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 |
# File 'lib/rex/text.rb', line 365 def self.to_java(str, name = "shell") buff = "byte #{name}[] = new byte[]\n{\n" cnt = 0 max = 0 str.unpack('C*').each do |c| buff << ", " if max > 0 buff << "\t" if max == 0 buff << sprintf('(byte) 0x%.2x', c) max +=1 cnt +=1 if (max > 7) buff << ",\n" if cnt != str.length max = 0 end end buff << "\n};\n" return buff end |
.to_js_comment(str, wrap = DefaultWrap) ⇒ Object
Creates a javascript-style comment
337 338 339 |
# File 'lib/rex/text.rb', line 337 def self.to_js_comment(str, wrap = DefaultWrap) return wordwrap(str, 0, wrap, '', '// ') end |
.to_mixed_case_array(str) ⇒ Array<String>
Takes a string, and returns an array of all mixed case versions.
982 983 984 985 986 987 988 989 990 991 992 993 994 995 |
# File 'lib/rex/text.rb', line 982 def self.to_mixed_case_array(str) letters = [] str.scan(/./).each { |l| letters << [l.downcase, l.upcase] } coords = [] (1 << str.size).times { |i| coords << ("%0#{str.size}b" % i) } mixed = [] coords.each do |coord| c = coord.scan(/./).map {|x| x.to_i} this_str = "" c.each_with_index { |d,i| this_str << letters[i][d] } mixed << this_str end return mixed.uniq end |
.to_num(str, wrap = DefaultWrap) ⇒ Object
Creates a comma separated list of numbers
259 260 261 262 263 264 265 266 267 268 269 270 271 272 |
# File 'lib/rex/text.rb', line 259 def self.to_num(str, wrap = DefaultWrap) code = str.unpack('C*') buff = "" 0.upto(code.length-1) do |byte| if(byte % 15 == 0) and (buff.length > 0) buff << "\r\n" end buff << sprintf('0x%.2x, ', code[byte]) end # strip , at the end buff = buff.chomp(', ') buff << "\r\n" return buff end |
.to_octal(str, prefix = "\\") ⇒ String
Returns the escaped octal version of the supplied string
595 596 597 598 599 600 601 602 |
# File 'lib/rex/text.rb', line 595 def self.to_octal(str, prefix = "\\") octal = "" str.each_byte { |b| octal << "#{prefix}#{b.to_s 8}" } return octal end |
.to_perl(str, wrap = DefaultWrap, name = "buf") ⇒ Object
Converts a raw string into a perl buffer
344 345 346 |
# File 'lib/rex/text.rb', line 344 def self.to_perl(str, wrap = DefaultWrap, name = "buf") return hexify(str, wrap, '"', '" .', "my $#{name} = \n", '";') end |
.to_perl_comment(str, wrap = DefaultWrap) ⇒ Object
Creates a perl-style comment
437 438 439 |
# File 'lib/rex/text.rb', line 437 def self.to_perl_comment(str, wrap = DefaultWrap) return wordwrap(str, 0, wrap, '', '# ') end |
.to_powershell(str, name = "buf") ⇒ Object
Converts a raw string to a powershell byte array
388 389 390 |
# File 'lib/rex/text.rb', line 388 def self.to_powershell(str, name = "buf") return Rex::Powershell::Script.to_byte_array(str, name) end |
.to_python(str, wrap = DefaultWrap, name = "buf") ⇒ Object
Converts a raw string into a python buffer
351 352 353 |
# File 'lib/rex/text.rb', line 351 def self.to_python(str, wrap = DefaultWrap, name = "buf") return hexify(str, wrap, "#{name} += \"", '"', "#{name} = \"\"\n", '"') end |
.to_rand_case(str) ⇒ String
Converts a string to random case
964 965 966 967 968 969 970 |
# File 'lib/rex/text.rb', line 964 def self.to_rand_case(str) buf = str.dup 0.upto(str.length) do |i| buf[i,1] = rand(2) == 0 ? str[i,1].upcase : str[i,1].downcase end return buf end |
.to_raw(str) ⇒ Object
Returns the raw string
451 452 453 |
# File 'lib/rex/text.rb', line 451 def self.to_raw(str) return str end |
.to_ruby(str, wrap = DefaultWrap, name = "buf") ⇒ Object
Converts a raw string into a ruby buffer
252 253 254 |
# File 'lib/rex/text.rb', line 252 def self.to_ruby(str, wrap = DefaultWrap, name = "buf") return hexify(str, wrap, '"', '" +', "#{name} = \n", '"') end |
.to_ruby_comment(str, wrap = DefaultWrap) ⇒ Object
Creates a ruby-style comment
305 306 307 |
# File 'lib/rex/text.rb', line 305 def self.to_ruby_comment(str, wrap = DefaultWrap) return wordwrap(str, 0, wrap, '', '# ') end |
.to_unescape(data, endian = ENDIAN_LITTLE, prefix = '%%u') ⇒ Object
Returns a unicode escaped string for Javascript
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 |
# File 'lib/rex/text.rb', line 567 def self.to_unescape(data, endian=ENDIAN_LITTLE, prefix='%%u') data << "\x41" if (data.length % 2 != 0) dptr = 0 buff = '' while (dptr < data.length) c1 = data[dptr,1].unpack("C*")[0] dptr += 1 c2 = data[dptr,1].unpack("C*")[0] dptr += 1 if (endian == ENDIAN_LITTLE) buff << sprintf("#{prefix}%.2x%.2x", c2, c1) else buff << sprintf("#{prefix}%.2x%.2x", c1, c2) end end return buff end |
.to_unicode(str = '', type = 'utf-16le', mode = '', size = '') ⇒ Object
Converts standard ASCII text to a unicode string.
Supported unicode types include: utf-16le, utf16-be, utf32-le, utf32-be, utf-7, and utf-8
Providing ‘mode’ provides hints to the actual encoder as to how it should encode the string.
Only UTF-7 and UTF-8 use “mode”.
utf-7 by default does not encode alphanumeric and a few other characters. By specifying the mode of “all”, then all of the characters are encoded, not just the non-alphanumeric set. to_unicode(str, ‘utf-7’, ‘all’)
utf-8 specifies that alphanumeric characters are used directly, eg “a” is just “a”. However, there exist 6 different overlong encodings of “a” that are technically not valid, but parse just fine in most utf-8 parsers. (0xC1A1, 0xE081A1, 0xF08081A1, 0xF8808081A1, 0xFC80808081A1, 0xFE8080808081A1). How many bytes to use for the overlong enocding is specified providing ‘size’. to_unicode(str, ‘utf-8’, ‘overlong’, 2)
Many utf-8 parsers also allow invalid overlong encodings, where bits that are unused when encoding a single byte are modified. Many parsers will ignore these bits, rendering simple string matching to be ineffective for dealing with UTF-8 strings. There are many more invalid overlong encodings possible for “a”. For example, three encodings are available for an invalid 2 byte encoding of “a”. (0xC1E1 0xC161 0xC121).
By specifying “invalid”, a random invalid encoding is chosen for the given byte size. to_unicode(str, ‘utf-8’, ‘invalid’, 2)
utf-7 defaults to ‘normal’ utf-7 encoding utf-8 defaults to 2 byte ‘normal’ encoding
681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 |
# File 'lib/rex/text.rb', line 681 def self.to_unicode(str='', type = 'utf-16le', mode = '', size = '') return '' if not str case type when 'utf-16le' return str.unpack('C*').pack('v*') when 'utf-16be' return str.unpack('C*').pack('n*') when 'utf-32le' return str.unpack('C*').pack('V*') when 'utf-32be' return str.unpack('C*').pack('N*') when 'utf-7' case mode when 'all' return str.gsub(/./){ |a| out = '' if 'a' != '+' out = encode_base64(to_unicode(a, 'utf-16be')).gsub(/[=\r\n]/, '') end '+' + out + '-' } else return str.gsub(/[^\n\r\t\ A-Za-z0-9\'\(\),-.\/\:\?]/){ |a| out = '' if a != '+' out = encode_base64(to_unicode(a, 'utf-16be')).gsub(/[=\r\n]/, '') end '+' + out + '-' } end when 'utf-8' if size == '' size = 2 end if size >= 2 and size <= 7 string = '' str.each_byte { |a| if (a < 21 || a > 0x7f) || mode != '' # ugh. turn a single byte into the binary representation of it, in array form bin = [a].pack('C').unpack('B8')[0].split(//) # even more ugh. bin.collect!{|a_| a_.to_i} out = Array.new(8 * size, 0) 0.upto(size - 1) { |i| out[i] = 1 out[i * 8] = 1 } i = 0 byte = 0 bin.reverse.each { |bit| if i < 6 mod = (((size * 8) - 1) - byte * 8) - i out[mod] = bit else byte = byte + 1 i = 0 redo end i = i + 1 } if mode != '' case mode when 'overlong' # do nothing, since we already handle this as above... when 'invalid' done = 0 while done == 0 # the ghetto... bits = [7, 8, 15, 16, 23, 24, 31, 32, 41] bits.each { |bit| bit = (size * 8) - bit if bit > 1 set = rand(2) if out[bit] != set out[bit] = set done = 1 end end } end else raise TypeError, 'Invalid mode. Only "overlong" and "invalid" are acceptable modes for utf-8' end end string << [out.join('')].pack('B*') else string << [a].pack('C') end } return string else raise TypeError, 'invalid utf-8 size' end when 'uhwtfms' # suggested name from HD :P load_codepage() string = '' # overloading mode as codepage if mode == '' mode = 1252 # ANSI - Latan 1, default for US installs of MS products else mode = mode.to_i end if @@codepage_map_cache[mode].nil? raise TypeError, "Invalid codepage #{mode}" end str.each_byte {|byte| char = [byte].pack('C*') possible = @@codepage_map_cache[mode]['data'][char] if possible.nil? raise TypeError, "codepage #{mode} does not provide an encoding for 0x#{char.unpack('H*')[0]}" end string << possible[ rand(possible.length) ] } return string when 'uhwtfms-half' # suggested name from HD :P load_codepage() string = '' # overloading mode as codepage if mode == '' mode = 1252 # ANSI - Latan 1, default for US installs of MS products else mode = mode.to_i end if mode != 1252 raise TypeError, "Invalid codepage #{mode}, only 1252 supported for uhwtfms_half" end str.each_byte {|byte| if ((byte >= 33 && byte <= 63) || (byte >= 96 && byte <= 126)) string << "\xFF" + [byte ^ 32].pack('C') elsif (byte >= 64 && byte <= 95) string << "\xFF" + [byte ^ 96].pack('C') else char = [byte].pack('C') possible = @@codepage_map_cache[mode]['data'][char] if possible.nil? raise TypeError, "codepage #{mode} does not provide an encoding for 0x#{char.unpack('H*')[0]}" end string << possible[ rand(possible.length) ] end } return string else raise TypeError, 'invalid utf type' end end |
.to_utf8(str) ⇒ String
This method will discard invalid characters
Converts US-ASCII to UTF-8, skipping over any characters which don’t convert cleanly. This is a convenience method that wraps String#encode with non-raising default paramaters.
462 463 464 |
# File 'lib/rex/text.rb', line 462 def self.to_utf8(str) str.encode('utf-8', { :invalid => :replace, :undef => :replace, :replace => '' }) end |
.to_vbapplication(str, name = "buf") ⇒ Object
Converts a raw string into a vba buffer
416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 |
# File 'lib/rex/text.rb', line 416 def self.to_vbapplication(str, name = "buf") return "#{name} = Array()" if str.nil? or str.empty? code = str.unpack('C*') buff = "#{name} = Array(" maxbytes = 20 1.upto(code.length) do |idx| buff << code[idx].to_s buff << "," if idx < code.length - 1 buff << " _\r\n" if (idx > 1 and (idx % maxbytes) == 0) end buff << ")\r\n" return buff end |
.to_vbscript(str, name = "buf") ⇒ Object
Converts a raw string to a vbscript byte array
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 |
# File 'lib/rex/text.rb', line 395 def self.to_vbscript(str, name = "buf") return "#{name}" if str.nil? or str.empty? code = str.unpack('C*') buff = "#{name}=Chr(#{code[0]})" 1.upto(code.length-1) do |byte| if(byte % 100 == 0) buff << "\r\n#{name}=#{name}" end # exe is an Array of bytes, not a String, thanks to the unpack # above, so the following line is not subject to the different # treatments of String#[] between ruby 1.8 and 1.9 buff << "&Chr(#{code[byte]})" end return buff end |
.to_words(str, strict = false) ⇒ Object
Returns the words in str
as an Array.
strict - include only words, no boundary characters (like spaces, etc.)
542 543 544 545 546 |
# File 'lib/rex/text.rb', line 542 def self.to_words( str, strict = false ) splits = str.split( /\b/ ) splits.reject! { |w| !(w =~ /\w/) } if strict splits end |
.ungzip(str) ⇒ String
Uncompresses a string using gzip
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 |
# File 'lib/rex/text.rb', line 1672 def self.ungzip(str) raise RuntimeError, "Gzip support is not present." if (!zlib_present?) s = "" s.force_encoding('ASCII-8BIT') if s.respond_to?(:encoding) gz = Zlib::GzipReader.new(StringIO.new(str, 'rb')) s << gz.read gz.close return s end |
.unicode_filter_decode(str) ⇒ Object
1917 1918 1919 |
# File 'lib/rex/text.rb', line 1917 def self.unicode_filter_decode(str) str.to_s.gsub( /\$U\$([\x20-\x2c\x2e-\x7E]*)\-0x([A-Fa-f0-9]+)/n ){|m| [$2].pack("H*") } end |
.unicode_filter_encode(str) ⇒ Object
A custom unicode filter for dealing with multi-byte strings on a 8-bit console Punycode would have been more “standard”, but it requires valid Unicode chars
1909 1910 1911 1912 1913 1914 1915 |
# File 'lib/rex/text.rb', line 1909 def self.unicode_filter_encode(str) if (str.to_s.unpack("C*") & ( LowAscii + HighAscii + "\x7f" ).unpack("C*")).length > 0 str = "$U$" + str.unpack("C*").select{|c| c < 0x7f and c > 0x1f and c != 0x2d}.pack("C*") + "-0x" + str.unpack("H*")[0] else str end end |
.uri_decode(str) ⇒ Object
Decode a URI encoded string
950 951 952 |
# File 'lib/rex/text.rb', line 950 def self.uri_decode(str) str.gsub(/(%[a-z0-9]{2})/i){ |c| [c[1,2]].pack("H*") } end |
.uri_encode(str, mode = 'hex-normal') ⇒ Object
Encode a string in a manor useful for HTTP URIs and URI Parameters.
864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 |
# File 'lib/rex/text.rb', line 864 def self.uri_encode(str, mode = 'hex-normal') return "" if str == nil return str if mode == 'none' # fast track no encoding all = /./ noslashes = /[^\/\\]+/ # http://tools.ietf.org/html/rfc3986#section-2.3 normal = /[^a-zA-Z0-9\/\\\.\-_~]+/ case mode when 'hex-all' return str.gsub(all) { |s| Rex::Text.to_hex(s, '%') } when 'hex-normal' return str.gsub(normal) { |s| Rex::Text.to_hex(s, '%') } when 'hex-noslashes' return str.gsub(noslashes) { |s| Rex::Text.to_hex(s, '%') } when 'hex-random' res = '' str.each_byte do |c| b = c.chr res << ((rand(2) == 0) ? b.gsub(all) { |s| Rex::Text.to_hex(s, '%') } : b.gsub(normal){ |s| Rex::Text.to_hex(s, '%') } ) end return res when 'u-all' return str.gsub(all) { |s| Rex::Text.to_hex(Rex::Text.to_unicode(s, 'uhwtfms'), '%u', 2) } when 'u-normal' return str.gsub(normal) { |s| Rex::Text.to_hex(Rex::Text.to_unicode(s, 'uhwtfms'), '%u', 2) } when 'u-noslashes' return str.gsub(noslashes) { |s| Rex::Text.to_hex(Rex::Text.to_unicode(s, 'uhwtfms'), '%u', 2) } when 'u-random' res = '' str.each_byte do |c| b = c.chr res << ((rand(2) == 0) ? b.gsub(all) { |s| Rex::Text.to_hex(Rex::Text.to_unicode(s, 'uhwtfms'), '%u', 2) } : b.gsub(normal){ |s| Rex::Text.to_hex(Rex::Text.to_unicode(s, 'uhwtfms'), '%u', 2) } ) end return res when 'u-half' return str.gsub(all) { |s| Rex::Text.to_hex(Rex::Text.to_unicode(s, 'uhwtfms-half'), '%u', 2) } else raise TypeError, "invalid mode #{mode.inspect}" end end |
.wordwrap(str, indent = 0, col = DefaultWrap, append = '', prepend = '') ⇒ Object
Wraps text at a given column using a supplied indention
1073 1074 1075 1076 |
# File 'lib/rex/text.rb', line 1073 def self.wordwrap(str, indent = 0, col = DefaultWrap, append = '', prepend = '') return str.gsub(/.{1,#{col - indent}}(?:\s|\Z)/){ ( (" " * indent) + prepend + $& + append + 5.chr).gsub(/\n\005/,"\n").gsub(/\005/,"\n")} end |
.xml_char_encode(str) ⇒ Object
Encode an ASCII string so it’s safe for XML. It’s a wrapper for to_hex_ascii.
943 944 945 |
# File 'lib/rex/text.rb', line 943 def self.xml_char_encode(str) self.to_hex_ascii(str, "&#x", 1, ";") end |
.zlib_deflate(str, level = Zlib::BEST_COMPRESSION) ⇒ String
Compresses a string using zlib
1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 |
# File 'lib/rex/text.rb', line 1621 def self.zlib_deflate(str, level = Zlib::BEST_COMPRESSION) if self.zlib_present? z = Zlib::Deflate.new(level) dst = z.deflate(str, Zlib::FINISH) z.close return dst else raise RuntimeError, "Gzip support is not present." end end |
.zlib_inflate(str) ⇒ String
Uncompresses a string using zlib
1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 |
# File 'lib/rex/text.rb', line 1637 def self.zlib_inflate(str) if(self.zlib_present?) zstream = Zlib::Inflate.new buf = zstream.inflate(str) zstream.finish zstream.close return buf else raise RuntimeError, "Gzip support is not present." end end |
.zlib_present? ⇒ Boolean
Returns true if zlib can be used.
1601 1602 1603 1604 1605 1606 1607 1608 |
# File 'lib/rex/text.rb', line 1601 def self.zlib_present? begin temp = Zlib return true rescue return false end end |