23+15=38 so "continuing on to position 28" doesn't make a lot of sense. Assuming that you meant (23,15) & (48,10), you could us unpack:

($1,$2) = unpack 'x23 A15 x10 a10', $var;
[download]

If you insist on using a regex, then with the same change of spec as above, you could use:

$var =~ m[^.{23}(.{15}}.{10}(.{10})];
[download]

Or if you really did mean overlapping bits then you could use substr

$1 = substr $var, 23, 15;
$2 = substr $var, 28, 10;
[download]

($1,$2) = unpack 'x23 a15 X10 a10', $var;
[download]

Or a regex:

$var =~ m[(?=.{23}(.{15}))(?=.{28}(.{10}))];
[download]

Of course, using named vars rather than $1 & $2 would make more sense :)

substr: Note that second parameter is 0-based. A warning will be given if the start position is beyond (but not at!) the end of the string; the result will be shorter than the requested length if $in isn't long enough.

$one = substr($in, 23, 15);
$two = substr($in, 28, 10);
[download]

$ perl -we'sub foo { print $_[0] } eval { foo(substr "abc", 4, 1); 1} 
+or die "croak: $@"'
croak: substr outside of string at -e line 1.
[download]

$in =~ /^  (?=.{23}(.{15}))   # field one
           (?=.{28}(.{10}))   # field two
       /xs
   or warn "bad input: $in ";
[download]

You can do overlapping fields with unpack.

my $data = "123";
my @data = unpack "A2X1A2", $data;
print "@data";
[download]

This prints

12 23
[download]



holli, /regexed monk/

@_ = a..z;
$_ = join '', @_;

/
  .{5}    # 5 symbols neglected
  (.{3})  # next 3 captured
  .{5}    # another 5 missed
  (.{3})  # and again 3 captured
/x;

print "$1 $2 \n"

__END__

STDOUT: fgh nop
where:
1 a 
2 b 
3 c 
4 d 
5 e 
6 f 
7 g 
8 h 
9 i 
10 j 
11 k 
12 l 
13 m 
14 n 
15 o 
16 p 
17 q 
18 r 
19 s 
20 t 
21 u 
22 v 
23 w 
24 x 
25 y 
26 z
[download]