We need to know how those are encoded in your data. Are they octets representing ASCII characters or are they 32-bit binary words? Your expressions for the start and stop strings contain ten and eight characters, respectively, so assumptions are hard to make.

Take a look at the index function. It could work in either case, so long as the search substring used the same encoding as the data.

    my $raw = join '', <DATA>;
    $raw =~ s/\n//g;

    if(my($encoded) =
       ($raw =~ /0002000000(.*?)00020400/)) {

        while($encoded =~ /(..)/g) {
            print chr (hex($1)), "\n";
        }
    }

__DATA__
045a010000020000004c45534f4e
4452412043414c4c454420424143
4b2c204920414456495345442054
48415420574500020400
[download]

L
E
S
O
N
D
R
A
 
C
A
L
L
E
D
 
B
A
C
K
,
[download]

The same, but with an unpack:

my $raw = do { local $/; <DATA> };    # inline slurp
$raw =~ s/\s//g;

print map { chr hex } unpack '(A2)*', $1
   if $raw =~ m/0002000000(.*?)00020400/;
[download]

Perhaps a bit too idiomatic, but I prefer using unpack to split characters into fixed widths. It is a tiny bit faster, though not blazingly so:

             Rate  regex unpack
regex    953336/s     --   -38%
unpack  1549170/s    62%     --
[download]

Taking the simplest interpretation of your problem description and modifying the sample data somewhat, the following may be what you want:

use warnings;
use strict;

my $start = '0020';
my $end = '0204';

my $data = join "", <DATA>;

pos ($data) = 0;
while (pos ($data) < length ($data))
  {
  last if $data !~ /\G.*?($start)/gis;
  my $begin = pos ($data);
  last if $data !~ /\G.*?($end)/gis;
  my $end = pos ($data) - length ($end);
  print ((substr $data, $begin, $end - $begin) . "\n");
  }
  
__DATA__
045a010000020000004c4553 4f4e4452412043414c4c4544 204241434b2c20492041
+4456
00020400 495345442054484154205745

prints:
000004c4553 4f4e4452412043414c4c4544 204241434b2c204920414456
00
[download]

There is no x00020400 in the input data supplied. Should there be more data in your sample?

- the start token is x00020000

- his data is 32 bit (a.k.a 8 decoded nybbles)

The second trap to avoid is matching across 8 byte boundaries, which, as can be seen in the code of one of the replies, but was expressed as a preference rather than a necessity, can be done using unpack.