You need to pack the hex representation into a binary string, so if you have '112233' you need to create the bytes "\x11\x22\x33". Then you can use the bitwise operators on these byte strings to do what you want.

Here's a nice way to do the conversions:

use strict;
use warnings;
use 5.010;  # just needed for say()

sub unascii {   pack 'h*', $_[0]; }
sub   ascii { unpack 'h*', $_[0]; }


say ascii unascii('aabbcc') ^ unascii('112233');
# output: bb99ff
[download]

See pack, unpack and perlpacktut for more details.

"unascii" and "ascii" aren't very clear to me. I would call them "hex_to_bytes" and "bytes_to_hex" respectively.

#!/usr/bin/perl -w
use strict;

printf "%X\n", ord('a');  #61
printf "%X\n", ord('b');  #62
print chr(0x61);          #a
[download]

Update: I think Moritz is on it.

pack() and unpack() are cool critters, but sometimes you have to stare at it for awhile. Example from the doc's:
sub ordinal { unpack("W",$_[0]); } # same as ord()

ord() and chr() are pretty "lightweight" critters. Without testing, I don't know if some kind of substr() based approach would be slower or faster. I assume for crypto, speed would be a major factor. On this performance point, I just don't know at the moment.

$a = 0xaabbcc;
$b = 0x112233;
printf '%X', $a ^ $b;
[download]

I think this is good as far as it goes, but I would assume that the OP wants to XOR some humongous things that cannot be represented as simple Perl numeric scalar values? In this case, use hex() function.

my $x = "aabbcc"; 
my $y = "112233";

printf '%x', hex($x) ^ hex($y); #bb99ff
[download]

This causes integer overflow if $x and $y are "too big".

I give an input of say "aabbcc" and I want to XOR with "112233". The answer should be "bb99ff"

my $s='112233'; 
my $t='aabbcc'; 
my $x=hex($s)^hex($t); 
printf('%0x', $x);
[download]

Note that this solution too is limited by the size of the biggest integer you can store in a perl scalar, which is usally 52 bit from the mantissa of a double precision floating point, or 64 bit for an integer on 64bit platforms (not sure about the sign, so could be 63 usable bits for this purpose).

Perl 6 - second systems done right

Here's a solution that works on hex strings, so allows you to work with hex numbers larger than the maximum integers Perl can handle...

use 5.010;
use strict;
use Carp qw/croak/;
use List::Util qw/max/;

sub xor_strings
{
    croak "should be passed two arguments" unless @_==2;
    state $chunk_size = 4;
    state $pattern    = sprintf '%%0%dx', $chunk_size;
    
    # Make strings equal length, and a multiple of $chunk_size.
    my $length = max(map { length $_ } @_);
    $length += $chunk_size - ($length % $chunk_size);
    my @strings = map { ('0'x($length - length $_)) . $_ } @_;
    
    # Join results of each chunk
    return join q{},
        map {
            # Parse chunk hex to an integer
            my $i = $_;
            my @nums = map { hex substr $_, $i*$chunk_size, $chunk_siz
+e } @strings;
            # Xor them and convert to hex.
            sprintf $pattern, $nums[0] ^ $nums[1]
        }
        0 .. ($length/$chunk_size)-1;
}

say xor_strings(
    '112233112233112233112233112233112233112233112233112233',
    'aabbccaabbccaabbccaabbccaabbccaabbccaabbccaabbcc112233',
    );
[download]

The chunk size of 4 is fairly conservative. It means that the string in processed in four-digit (i.e. 16 bit) chunks. You can probably get a minor speed up using a larger chunk size if you know that your computer will be able to handle it. The returned value will be left-padded with zeroes to be a length that is a multiple of the chunk size.

perl -E'sub Monkey::do{say$_,for@_,do{($monkey=[caller(0)]->[3])=~s{::}{ }and$monkey}}"Monkey say"->Monkey::do'

"^" converts floats to machine integers, so you're limited to 32/64, not 5253/64.

Maybe not relevant here, but for future reference, there is a POSIX character class [:print:] that can be used in a Perl regex to emulate the C isprint() function. Throwing "non-printable" control characters to a terminal interface can cause "troubles" to say the least. Basically this character class says whether or not the "printer" can render this ASCII character on the screen.

Or, one could embrace the 21st century and use /\p{Print}/ instead of /[:print:]/. No need to restrict yourself to 256 code points, and subject yourself to locale. The era of 5.005 is over! ;-)

Your point is well taken, however from the problem statement in this case, it appears that "bytes" are the unit of interest.