Chef-REST-Client

 view release on metacpan or  search on metacpan

lib/Chef.pm  view on Meta::CPAN

    my ($self,$organization_name) = (@_);
       $self->{ 'ORGANIZATION_NAME' } = $organization_name if defined $organization_name;
    return $self->{ 'ORGANIZATION_NAME' };
  }
  sub hosted_chef {
    my ($self,$hosted_chef) = (@_);
       $self->{ 'HOSTED_CHEF_' } = $hosted_chef if defined $server;;
    return $self->{ 'HOSTED_CHEF' };
  }
  
  sub private_key {
    my ($self,$private_key) = (@_);
           $self->{ 'CHEF_CLIENT_PRIVATE_KEY' } = $private_key if defined $private_key;
    return $self->{ 'CHEF_CLIENT_PRIVATE_KEY' };
  }
}#nwe

__DATA__

=pod

=head1 NAME 

lib/Chef/Encoder.pm  view on Meta::CPAN

1.1

=head1 SYNOPSIS

 use Chef::Encoder;

 my $obj  = new Chef::Encoder
           ( 
             'data'             => $data
           , 'private_key_file' => ../data/private_key.pem
           );
           
    $obj->pki->sign     ( 'data' => $data );
    $obj->sha1->digest  ( 'data' => $data );
    $obj->base64->encode( 'data' => $data );
    $obj->base64->decode( 'data' => $data );
    
=head1 DESCRIPTION

This module imiplements methods that perform the encoding and decoding and signing of the header

lib/Chef/Encoder.pm  view on Meta::CPAN

+------------------------+

=end html    

=head1 METHODS

=head2 Chef::Encoder( %params )

return new object initialzied as per %params.

=head2 private_key_file 

returns $private_key_file 

=head2 private_key

returns $private_key

=head2 data

returns $data

=cut


my @base;
BEGIN {

lib/Chef/Encoder.pm  view on Meta::CPAN

};

sub new {
  my $class = shift;
  my $param = {@_};
  my $self  = {};
  my $_tmp =  pop @base; #lib;  
  bless $self, $class;
    
    $self->{'data'            } = $param->{'data'} if defined $param->{'data'};
    $self->{'private_key_file'} = join '/' , @base , 'data', 'private_key.pem';
    $self->{'private_key_file'} = $param->{'private_key_file'} if defined $param->{'private_key_file'};

    push @base , $_tmp;
     
  return $self;
}

sub private_key_file {
  my $self = shift;
  return $self->{'private_key_file'};
}

sub private_key {
  my $self = shift;
  return $self->{'private_key'};
}

sub execute {
  my ($self , $command) = (@_);
  my $output = undef;
  eval {
  		$output = `$command`;
  		chomp($output);
  };
  return ($@) ? undef : $output;
}

sub data
{ $_[0]->{'data'} = $_[1] if defined $_[1]; return $_[0]->{'data'}; }

=pod

=head2 pki ( %params)

loads L<Chef::Encoder::pki> class and returns new object of class L<Chef::Encoder::pki>
it accepts ( 'private_key_file' => $private_key_file , 'private_key' => $private_key )
if none is provided it will try to use the values initialized from parent class L<Chef::Encoder>

=head3 NAME

Chef::Encoder::pki

=head3 VERSION

1.0

=head3 DESCRIPTION

This class provides siging request as per private key specified.

=head3 METHODS

=head4 B<sign>

returns signed data based on the private_key_file or privete_key

=cut

#----------------------------#
#  class Chef::Encoder::pki  #
#----------------------------#

sub pki {
  my $class = shift;
  my $param = {@_};
  
  package Chef::Encoder::pki;
  use parent qw{ Chef::Encoder };
  use Crypt::OpenSSL::RSA; 
  use File::Slurp;

  my $self = {};
  bless $self, qw { Chef::Encoder::pki };
  
  $self->{'private_key_file'} = (defined($param->{'private_key_file'}))?
                                         $param->{'private_key_file'}  :
                                         $class->private_key_file;
  $self->{'private_key'} = (defined($param->{'private_key'}))?
                                    $param->{'private_key'}  :
                                    $class->private_key;
  return $self;

    sub sign {
      my $self = shift;
      my $param = {@_};
      my $data = $param->{'data'};
      my $private_key = $self->private_key_file;

      return $self->execute("echo -n '$data'| openssl rsautl -sign -inkey $private_key| openssl enc -base64");
    }

    sub rsa_private {
      my $self = shift;
      my $param = {@_};
      $self->{'private_key'} = read_file( $param->{'private_key_file'} ) if
                                 defined( $param->{'private_key_file'} ) ;
                                 
      my $_openssl_rsa_obj;
      eval {
         $_openssl_rsa_obj = Crypt::OpenSSL::RSA->new_private_key( 
      								defined( $param->{'private_key'} ) ?
      								         $param->{'private_key'}   :
      								         $self->private_key 
                             );
      };
      return ($@)? $self : $_openssl_rsa_obj;
    }
    
    sub private_key {
      my $self = shift;

      if( !defined( $self->{'private_key'} ) ){
        $self->{'private_key'} = read_file( $self->private_key_file );
      }

      return $self->{'private_key'};
    }
    
    sub private_key_file {
      my $self = shift;
      return $self->{'private_key_file'};
    }

}# package pki ends

=pod

=head2 sha1 ( %params)

loads L<Chef::Encoder::sha1> class and returns new object of class L<Chef::Encoder::sha1>
it accepts ( 'data' => $data )

lib/Chef/Header.pm  view on Meta::CPAN

  sub header {
    my $class = shift;
    my $param = {@_};
    
    package Chef::Header::header;

    use parent -norequire,qw { Chef::Header };
       
    my $self = new Chef::Header::header();

    $self->_chef_encoder( new Chef::Encoder( 'private_key_file'  => $class->private_key ) );
    
    $self->Method          ($param->{'Method'         });
    $self->HashedPath      ($param->{'Path'           });
    $self->XOpsContentHash ($param->{'Content'        });
    #$self->XOpsTimestamp   ($param->{'X-Ops-Timestamp'  });
    $self->XOpsUserId      ($class->name               );
  
    #default_values
    #$self->Accept          ($param->{'Accept'         });
    $self->Host            ($class->server             );

lib/Chef/REST/Client.pm  view on Meta::CPAN

=head1 VERSION

1.2

=head1 SYNOPSIS

use Chef::REST::Client;

my $obj = new Chef::REST::Client
          ( 'chef_client_name' => $chef_client_name ,
            'chef_client_privaate_key' => $private_key );

   $obj->private_key( $private_key );
   $obj->name( $chef_client_name );
   $obj->roles('vagrant')->details;
   $obj->roles('vagrant','environments')->details
   $obj->roles->list;
   
   $obj->search( 'secrets' , {  q => 'id:centrify', rows => 1 } )->details
   
   $obj->environments(<env_name>,'cookbooks' , <cookbook_name>)->details;

   $obj->environments(<env_name>,'cookbooks_versions'

lib/Chef/REST/Client.pm  view on Meta::CPAN

use parent qw { Chef::REST };
use Mojo::JSON;
use Module::Load;
use vars qw { $AUTOLOAD };

sub new {
  my $class = shift;
  my $param = {@_};
  my $self  = $class->SUPER::new(@_);
     $self->name($param->{'chef_client_name'}) if defined $param->{'chef_client_name'};
     $self->private_key($param->{'chef_client_private_key'}) if defined $param->{'chef_client_private_key'};     
  bless $self, $class;
  return $self;
}

sub name {
  my ($self,$client_name) = (@_);
         $self->{ 'CHEF_CLIENT' } = $client_name if defined $client_name;
  return $self->{ 'CHEF_CLIENT' };
}

t/Chef/Encoder.t  view on Meta::CPAN

  pop @base;
  pop @base;    
  push @INC , join  '/', @base, 'lib';
};

use_ok( 'Chef::Encoder' );

use_ok(  'File::Slurp' );

my $obj = new_ok( 'Chef::Encoder' );
my $pk = join '/' , @base , 'data', 'private_key.pem';

if (  ! -e $pk )
{
   diag " $pk does not exist skipping all tests";
   done_testing;
   exit 0;
}

subtest 'sha1 tests' => sub {
  isa_ok( $obj->sha1 , 'Chef::Encoder::sha1' );

t/Chef/Encoder.t  view on Meta::CPAN

};

subtest 'base64 tests' => sub {
  isa_ok( $obj->base64 , 'Chef::Encoder::base64');
  #ok( $obj->base64( 'data' => 'bhavin' )->encode , 'encoding "bhavin" to base64 ');
};


subtest 'pki tests' => sub {
  isa_ok( $obj->pki , 'Chef::Encoder::pki' );
  ok( $obj->pki->rsa_private( 'private_key_file' => $pk )->sign( 'bhavin' ) , 'sign' );
  ok( $obj->pki
          ->rsa_private( 'private_key_file' => $pk )
          ->verify( 'bhavin',
                    $obj->pki
                        ->rsa_private( 'private_key_file' => $pk )
                        ->sign( 'bhavin' )
                  ),
             "verifying signature" 
          );
};

done_testing;

t/Chef/Header.t  view on Meta::CPAN

use_ok( 'Chef::Header' );
my $obj = new_ok( 'Chef::Header', [
    ]);
ok( $obj->header , 'header' );
ok( $obj->header->hash , 'header has' );
ok( $obj->header->chef_header, 'header chef header' );

subtest 'header verification' => sub {

	my $private_key_file = join '/', @base, 'data', 'private_key.pem';
	my $public_key_file  = join '/', @base, 'data', 'public_key.pem';

	plan skip_all => 'private and public key files not present' 
	unless -e $private_key_file && $public_key_file;

	plan skip_all => 'specific to env';

	use Crypt::OpenSSL::RSA;
	use File::Slurp;

	my $h = $obj->header->chef_header->XOpsAuthorization ;
	my $e = join '', ( $h->{'X-Ops-Authorization-1'} ,
   	                $h->{'X-Ops-Authorization-2'} ,
      	             $h->{'X-Ops-Authorization-3'} ,
         	          $h->{'X-Ops-Authorization-4'} ,
            	       $h->{'X-Ops-Authorization-5'} ,
               	    $h->{'X-Ops-Authorization-6'} );

  	my $public_key = read_file( $public_key_file );
  	my $private_key = read_file ( $private_key_file);
	
	my $rsa_pri = Crypt::OpenSSL::RSA->new_private_key( $private_key );
  
	my $chef_header = $obj->header->chef_header->to_string;
  
  	use Chef::Encoder;
  	my $ce = new Chef::Encoder();
  	my $sign = $rsa_pri->sign( $chef_header );
    
  pass;
};