Bugs:

• = is the assignment operator, not a comparison operator. Use == to compare numbers. Use eq to compare strings.

Improvements that can be made:

• Paragraph mode could be used here. Check out $/.
• There's no need to read in the whole file into memory.
• Using 3-arg open when possible is safer. (open(..., '<...') → open(..., '<', '...'))
• open is rather likely to fail. Check to make sure it succeeds.
• Using lexicals when possible is safer. (FILE → $fh)
• Uppercase variable names are usually reserved for constants.

Resulting code:

my $file_name = ...;
my $kwd       = ...;

open my $fh, '<', $file_name
   or die("Unable to open file \"$file_name\": $!\n");

local $/ = "";
while (<$fh>) {
   chomp;
   my @fields = split /:/, $_;
   if ($fields[1] eq $kwd) {
      print "$_\n\n";
   }
}
[download]

Update: You asked about writting it to another file:

my $fn_in  = ...;
my $fn_out = ...;
my $kwd    = ...;

open my $fh_in, '<', $fn_in
   or die("Unable to open file \"$fn_in\": $!\n");

open my $fh_out, '>', $fn_out
   or die("Unable to create file \"$fn_out\": $!\n");

local $/ = "";
while (<$fh_in>) {
   chomp;
   my @fields = split /:/, $_;
   if ($fields[1] eq $kwd) {
      print $fh_out "$_\n\n";
   }
}
[download]

$file = <FILE>;
[download]

local $/ = undef;  
$file = <FILE>;
[download]

$file = join("", <FILE>);
[download]

foreach $this_paragraph (@paras) { 
  ....
}
[download]

foreach my $this_paragraph (@paras) {
  my @split_para = split(/:/, $this_paragraph);
  if( $split_para[1] = $KWD ) {
    print $this_paragraph;
  }
}
[download]

• $split_para[1] = $KWD; # this SETS $split_para[1] to $KWD, and always evaluates to TRUE as long as $KWD was true. You probably want something like '$split_para[1] eq $KWD' instead.
• If the paragraph doesn't look like 'something:KEYWORD:something....', this test will fail. Perl's lists/arrays start counting at 0 instead of 1, so the first list element is '$split_para[0]'. You could test the first one with '$split_para[0] eq $KWD' if your intended text looks like 'KEYWORD:something ....'
• It's not really necessary to break up the paragraph into pieces to check if it's got the keyword in it, Perl programmers are very fond of using regular expressions for this sort of thing...

foreach my $this_paragraph (@paras) {
  if( $this_paragraph =~ /^$KWD:/s ) { 
    print $this_paragraph;
    # This works if the paragraph looks like 'KEYWORD: ...'
  }
}
[download]

foreach my $this_paragraph (@paras) {
  if( $this_paragraph =~ /:$KWD\b/s ) { 
    print $this_paragraph;
    # This works if the paragraph looks like '.... :KEYWORD ...'
  }
}
[download]

• perlretut - Regular Expressions tutorial
• open - Syntax for the 'open' command. Although the examples in the Learning Perl book demonstrate it, there are 'safer' ways of opening files. As the other monks have pointed out, you should usually use scalar filehandles (open my $fh, ....) instead of the older (open FILE, ...), and you should always check the return code from 'open' to make sure it worked.
• http://www.oreilly.com/catalog/perlbp/ - O'Reilly's 'Perl Best Practices' book. Although this doesn't teach you how to write Perl programs, it's a great book new Perl programmers should read if you plan to write Perl code professionally.
• http://www.oreilly.com/catalog/pperl3/ - The companion book to 'Learning Perl', 'Programming Perl' is a reference to the built-in Perl commands and the tools and libraries that come with it.

Perl has a paragraph input mode which is activated by setting the variable $/ to an empty string. (See perlvar for more.) That lets you process a file by paragraphs as you read it.

Here is a revised version of your code (untested):

my $KWD = shift;
my $file = 'input.txt';
open my $in, '<', $file or die "Can't read '$file': $!";
local $/ = '';
while ( my $para = <$in> ) {
    my ( $first) = split /:/, $para;
    print $para if $first eq $KWD;
}
[download]

/^$KWD:/ and print while <in>;
[download]

man you guys ROCK!!! thanks for all the input and reference links.....

One of the best pieces of general advice we can give you is use strictures: use strict; use warnings;. They often pick up issues before they become issues.

A cute trick that Perl can do is use a different "line terminator" than the default by setting the $/ special variable. So you can:

my @paras = do {local $/ = "\n\n"; <FILE>};
[download]

which locally (to the do) overrides the line end terminator to be "\n\n", then uses <FILE> in an array context (my @paras = is array context) to "slurp" the file a paragraph at a time into @paras.

You can then use grep to filter out all the paragraphs that don't start with the keyword:

my @wanted = grep {/^\Q$KWD:\E/} @paras;
[download]

which uses a regular expression (see perlretut for a start) to check that the paragraph starts with the required key word. Now you can print the result out:

print OUTFILE @wanted;
[download]