view release on metacpan or  search on metacpan

lib/Crypt/RSA/Key/Private/SSH.pm  view on Meta::CPAN

    my $cipher_type = $buffer->get_int8;
    $buffer->get_int32;   ## Reserved data.

    $buffer->get_int32;   ## Private key bits.
    $key->n( $buffer->get_mp_int );
    $key->e( $buffer->get_mp_int );

    $key->Identity( $buffer->get_str );     ## Comment.

    if ($cipher_type != 0) {
        my $cipher_names = $CIPHERS{$cipher_type} or
            croak "Unknown cipher '$cipher_type' used in key file";
        my $cipher_name;
        foreach my $name (@$cipher_names) {
          my $class = "Crypt::$name";
          (my $file = $class) =~ s=::|'=/=g;
          if ( eval { require "$file.pm"; 1 } ) {
            $cipher_name = $name; last;
          }
        }
        if (!defined $cipher_name) {
          croak "Unsupported cipher '$cipher_names->[0]': $@";
        }

        my $cipher = Crypt::CBC->new( -key    => $passphrase,
                                      -cipher => $cipher_name );
        my $decrypted =
            $cipher->decrypt($buffer->bytes($buffer->offset));
        $buffer->empty;
        $buffer->append($decrypted);
    }

    my $check1 = $buffer->get_int8;
    my $check2 = $buffer->get_int8;
    unless ($check1 == $buffer->get_int8 &&
            $check2 == $buffer->get_int8) {
        croak "Bad passphrase supplied for key file";
    }

    $key->d( $buffer->get_mp_int );
    $key->u( $buffer->get_mp_int );
    $key->p( $buffer->get_mp_int );
    $key->q( $buffer->get_mp_int );

    # Restore other variables.
    $key->phi( ($key->p - 1) * ($key->q - 1) );
    $key->dp( $key->d % ($key->p - 1) );
    $key->dq( $key->d % ($key->q - 1) );
    # Our passphrase may be just temporary for the serialization, and have
    # nothing to do with the key.  So don't store it.
    #$key->{Password} = $passphrase unless defined $key->{Password};

    $key;
}


sub serialize {
    my($key, %params) = @_;

    # We could reveal it, but (1) what if it was hidden with a different
    # password, and (2) they may not want to revealed (even if hidden after).
    croak "Cowardly refusing to serialize a hidden key"
      if $key->{Hidden};

    my $passphrase = defined $params{Password} ? $params{Password}
                   : defined $key->Password    ? $key->Password
                   : '';
    my $cipher_name = defined $params{Cipher} ? $params{Cipher}
                    : defined $key->Cipher    ? $key->Cipher
                    : 'Blowfish';

    # If they've given us no passphrase, we will be unencrypted.
    my $cipher_type = 0;

    if ($passphrase ne '') {
      $cipher_type = $CIPHERS_TEXT{ uc $cipher_name };
      croak "Unknown cipher: '$cipher_name'" unless defined $cipher_type;
    }

    my $buffer = new Crypt::RSA::Key::Private::SSH::Buffer;
    my($check1, $check2);
    $buffer->put_int8($check1 = int rand 255);
    $buffer->put_int8($check2 = int rand 255);
    $buffer->put_int8($check1);
    $buffer->put_int8($check2);

    $buffer->put_mp_int($key->d);
    $buffer->put_mp_int($key->u);
    $buffer->put_mp_int($key->p);
    $buffer->put_mp_int($key->q);

    $buffer->put_int8(0)
        while $buffer->length % 8;

    my $encrypted = new Crypt::RSA::Key::Private::SSH::Buffer;
    $encrypted->put_chars(PRIVKEY_ID);
    $encrypted->put_int8(0);
    $encrypted->put_int8($cipher_type);
    $encrypted->put_int32(0);

    $encrypted->put_int32(Crypt::RSA::DataFormat::bitsize($key->n));
    $encrypted->put_mp_int($key->n);
    $encrypted->put_mp_int($key->e);
    $encrypted->put_str($key->Identity || '');

    if ($cipher_type) {
        my $cipher_names = $CIPHERS{$cipher_type};
        my $cipher_name;
        foreach my $name (@$cipher_names) {
          my $class = "Crypt::$name";
          (my $file = $class) =~ s=::|'=/=g;
          if ( eval { require "$file.pm"; 1 } ) {
            $cipher_name = $name; last;
          }
        }
        if (!defined $cipher_name) {
          croak "Unsupported cipher '$cipher_names->[0]': $@";
        }

        my $cipher = Crypt::CBC->new( -key    => $passphrase,
                                      -cipher => $cipher_name );