How to Fix Errors with the PowerShell WebAdministration Module

Posted on May 21, 2012 by sean • Posted in Programming, Windows • Tagged 32-bit, 64-bit, 688EEEE5-6A7E-422F-B2E1-6AF00DC944A6, 80040154, clsid, com, COMException, get-website, iis, management service, microsoft, powershell, programming, system32, syswow64, webadministration, windows • Leave a comment

The PowerShell WebAdministration module can be finicky. If you’re seeing COMException error messages, here are a few things you could try.

WebAdministration Errors

If you import the module using the 32-bit version of PowerShell, you might see the following.

PS > Import-Module WebAdministration
PS > Get-Website
Get-Website : Retrieving the COM class factory for component with CLSID {688EEEE5-6A7E-422F-B2E1-6AF00DC944A6} failed
  due to the following error: 80040154.
At line:1 char:12
+ Get-Website < <<<
    + CategoryInfo          : NotSpecified: (:) [Get-Website], COMException
    + FullyQualifiedErrorId : System.Runtime.InteropServices.COMException,Microsoft.IIs.PowerShell.Provider.GetWebsite
   Command

If you import the module using the 64-bit version of PowerShell, you might see this error.

PS > Import-Module WebAdministration
PS > Get-Website
format-default : Class not registered (Exception from HRESULT: 0x80040154 (REGDB_E_CLASSNOTREG))
    + CategoryInfo          : NotSpecified: (:) [format-default], COMException
    + FullyQualifiedErrorId : System.Runtime.InteropServices.COMException,Microsoft.PowerShell.Commands.FormatDefaultCommand

Continue reading →

How to fix Error: suffix or operands invalid for ‘push’ or ‘pop’

Posted on August 25, 2011 by sean • Posted in Linux, Programming • Tagged 32-bit, 64-bit, as, assembly, c, compiling, elf_i386, error, fix, gcc, invalid, ld, operands, pop, push, suffix • Leave a comment

If you compile a 32-bit assembly program (or a C program that contains assembly instructions) on a 64-bit machine you may see the following error:

# as -o example32bit.o example32bit.s
example32bit.s: Assembler messages:
example32bit.s:10: Error: suffix or operands invalid for `pop'

To fix this problem you need to pass the compiler or assembler a flag telling it you want to compile the software as 32-bit and not 64-bit.

The fix for C: Compiling with the -m32 flag

If you’re using gcc to compile a C program, pass in -m32. There’s a complete example here on my blog.

The fix for assembly: Compiling with the –32 flag

If you’re using as to compile an assembly program, pass in –32. Then when you link with ld pass in -m elf_i386. There’s a complete example here on my blog.

Happy hacking!

How to Compile 32-bit Assembly Programs on a 64-bit PC in Linux

Posted on August 25, 2011 by sean • Posted in Linux, Programming • Tagged --32, 32-bit, 64-bit, as, assembly, assembly primer for hackers, compiling, elf_i386, ld, linux • Leave a comment

Speaking of compiling 32-bit C programs, what about assembly language programs? Assembly varies considerably between machines as well, so it would be useful to know how to compile x86-32 software when you’re on x86-64. It’s relatively easy, so I’ll demonstrate the commands!

Compiling with the –32 flag

To compile 32-bit assembly programs with as you pass the –32 flag (found this under Target i386 options on the as man page). It’s pretty straight forward:

# as --32 -o example32bit.o example32bit.s

Linking using the -m flag

You’re not done yet! You still need to link the program and if you just tried that now you probably saw this:

# ld -o example32bit example32bit.o
ld: i386 architecture of input file `example32bit.o' is incompatible with i386:x86-64 output

Jeez ld! What’s your problem?

Well, the linker needs to know the architecture as well. Try passing -m elf_i386 so ld will calm down a bit.

# ld -m elf_i386 -o example32bit example32bit.o

Finished!

Your program should run now.

How to Compile 32-bit C Programs on a 64-bit PC in Linux

Posted on August 24, 2011 by sean • Posted in Linux, Programming • Tagged 32-bit, 64-bit, c, compiling, gcc, gcc-multilib, glibc, gnu, libc, linux • Leave a comment

I’ve been writing a lot of articles recently about compiling C and assembly programs on my 64-bit machine. But eventually I needed to compile a 32-bit program and I thought I would explain how I did that in case anyone else runs into trouble.

Using the -m32 flag

To compile a 32-bit program with gcc you can just use the m32 flag (which you’ll find under i386 and x86-64 Options on the gcc man page). But if you’re on a 64-bit machine, don’t be surprised if you see something like this:

# gcc -m32 -o example32bit example32bit.c
In file included from /usr/include/features.h:378,
                 from /usr/include/stdio.h:28,
                 from example32bit.c:1:
/usr/include/gnu/stubs.h:7:27: error: gnu/stubs-32.h: No such file or directory

Installing the 32-bit glibc headers

You see that because you don’t have the 32-bit glibc headers installed. That’s not a problem though, since most package managers should have them available for installation. If you’re on a Debian or Ubuntu machine you can install them like this:

# apt-get install gcc-multilib

Look ma, no compiler errors!

# gcc -m32 -o example32bit example32bit.c
#

Tada!

Testing Shellcode on a Non-Executable Stack or Heap

Posted on August 21, 2011 by sean • Posted in Linux, Programming, Security • Tagged 64-bit, amd, anonymous memory map, assembling, assembly, buffer, buffer overflow primer, c, eip, evp, execstack, fun and profit, gcc, gdb, hackers, hacking, heap, heap overflow, instruction pointer, intel, linux, nx bit, oscp, overflow, pentesting with backtrack, pointer, pointers, propolice, ret, return-to-libc, rip, segfault, segmentation fault, shell, shellcode, smashing the stack, ssp, stack, stack overflow, x86, xdbit • 1 Comment

If you’re learning about buffer overflows and shellcode, chances are you’re exploiting some stack-based vulnerabilities. If you’re like me you might also find that when you compile your programs they have stack execution disabled by default. So instead of getting excited as you see your shellcode blissfully running after smashing the stack, you might just see this instead:

Program received signal SIGSEGV, Segmentation fault.
0x0000000000601018 in shellcode ()

“Noooo! You can’t do this to me! I want to write exploits!”

Ok.. calm down.. we just need to turn on stack execution when compiling.

Continue reading →

Examining a Buffer Overflow in C and assembly with gdb

Posted on August 20, 2011 by sean • Posted in Linux, Programming, Security • Tagged 64-bit, addq, as, assembling, assembly, assembly primer for hackers, base pointer, buffer, buffer overflow primer, c, data, debugging, ebp, eip, fun and profit, functions, gas, gdb, getinput, gets, hackers, hacking, instruction pointer, int, leave, linux, main, movl, movq, oscp, overflow, pentesting with backtrack, pointer, pointers, popq, printf, pushq, puts, rbp, registers, ret, rip, root, segfault, segmentation fault, shell, smashing the stack, stabs, stack, stack overflow, string, strings, text, ub3r 1337, ub3r h4x0r, vivek ramachandran, x86 • 5 Comments

Welcome University of Maryland students! Thanks for visiting!

I’ve now finished Vivek Ramachandran’s Assembly Primer for Hackers and I’ve decided to move on to his Buffer Overflow Primer. I’ve exploited basic buffer overflows before, but I think going through his videos will give me more perspective now that I’ve brushed up on assembly.

In this article I’ll be stepping through the program in Vivek’s first video and providing some additional tips and tricks that I find useful when reviewing the program in gdb. I’m also on a 64-bit machine, so things are a bit different in gdb for me than they are in the video. Therefore it’s better that I write up my own explanations as I grasp the material so when I review later it will be more clear.

Continue reading →

Examining the Stack to Debug Segfaults with gdb

Posted on August 19, 2011 by sean • Posted in Linux, Programming, Security • Tagged 64-bit, addq, as, assembling, assembly, assembly primer for hackers, base pointer, data, debugging, ebp, eip, fun and profit, functions, gas, gdb, hackers, hacking, instruction pointer, int, linux, movl, movq, oscp, pentesting with backtrack, pointer, pointers, popq, pushq, rbp, registers, rip, segfault, segmentation fault, smashing the stack, stabs, stack, string, strings, text, x86 • 1 Comment

Earlier, while writing my compare strings method, I made a mistake in the code and came across a segmentation fault. Based on how the program executed I was pretty sure of approximately where the error was occurring, but rather than go and find the mistake I thought it would be a lot more useful to step through the program in the debugger and examine the problem that way. By doing this I’ll make it easier for myself to debug similar (more complex) problems in the future.

Continue reading →

Comparing Strings in Assembly Part 2

Posted on August 19, 2011 by sean • Posted in Linux, Programming • Tagged 64-bit, addl, addq, as, assembling, assembly, assembly primer for hackers, buffer, cmp, cmpsb, cmpstr, compare, data, df, df flag, functions, gas, hackers, hacking, int, leal, linx, loopz, movb, movl, movq, oscp, pentesting with backtrack, pointer, pointers, popq, pushq, registers, stack, string, strings, sub, text, x86 • Leave a comment

Earlier today I wrote some assembly code to compare 2 strings and print out whether or not they were equal to one another. I’ve been learning more assembly and so I thought I would tweak it a bit to improve the way it works and add more “features”. After some studying I’ve managed to get it working as a real function that actually takes arguments via the stack. On top of that, the function now returns a value that designates the index where the comparison failed; this is stored in the EAX register. Even further, by using a buffer in memory I was able to print a string that informs the user of the index where the comparison failed.

Continue reading →

Tech Blog is Tech

Exploring technology in the modern world

Tag Archives: 64-bit

How to Fix Errors with the PowerShell WebAdministration Module

WebAdministration Errors

How to fix Error: suffix or operands invalid for ‘push’ or ‘pop’

The fix for C: Compiling with the -m32 flag

The fix for assembly: Compiling with the –32 flag

Happy hacking!

How to Compile 32-bit Assembly Programs on a 64-bit PC in Linux

Compiling with the –32 flag

Linking using the -m flag

Finished!

How to Compile 32-bit C Programs on a 64-bit PC in Linux

Using the -m32 flag

Installing the 32-bit glibc headers

Look ma, no compiler errors!

Tada!

Testing Shellcode on a Non-Executable Stack or Heap

“Noooo! You can’t do this to me! I want to write exploits!”

Examining a Buffer Overflow in C and assembly with gdb

Examining the Stack to Debug Segfaults with gdb

Comparing Strings in Assembly Part 2