view release on metacpan or search on metacpan
lib/Net/Amazon/Config.pm view on Meta::CPAN
default = johndoe
[johndoe]
access_key_id = XXXXXXXXXXXXXXXXXXXX
secret_access_key = XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
certificate_file = my-cert.pem
private_key_file = my-key.pem
ec2_keypair_name = my-ec2-keypair
ec2_keypair_file = ec2-private-key.pem
aws_account_id = 0123-4567-8901
canonical_user_id = <64-character string>
view release on metacpan or search on metacpan
lib/Net/BitTorrent/Protocol/MSE/KeyExchange.pm view on Meta::CPAN
# -- Parameters --
field $infohash : param : reader;
field $is_initiator : param : reader;
# -- Internal State --
field $private_key;
field $public_key : reader;
field $shared_secret;
# -- Cipher State --
field $encrypt_rc4 : reader;
lib/Net/BitTorrent/Protocol/MSE/KeyExchange.pm view on Meta::CPAN
my $p = Math::BigInt->from_hex($P_STR);
my $g = Math::BigInt->new(2);
# Private Key: Random 160 bits
my $priv_hex = join '', map { sprintf "%02x", rand(256) } 1 .. 20;
$private_key = Math::BigInt->from_hex($priv_hex);
# Public Key: Y = G^X mod P
my $pub_val = $g->copy->bmodpow( $private_key, $p );
$public_key = $self->_int_to_bytes($pub_val);
}
method _int_to_bytes ($num) {
my $hex = $num->to_hex;
lib/Net/BitTorrent/Protocol/MSE/KeyExchange.pm view on Meta::CPAN
}
my $p = Math::BigInt->from_hex($P_STR);
my $remote_val = Math::BigInt->from_bytes($remote_pub_bytes);
# S = Y_remote ^ X_local mod P
my $s_val = $remote_val->copy->bmodpow( $private_key, $p );
$shared_secret = $self->_int_to_bytes($s_val);
return $shared_secret;
}
method get_secret () { return $shared_secret }
view release on metacpan or search on metacpan
lib/Net/Braintree/Configuration.pm view on Meta::CPAN
use Moose;
has merchant_id => (is => 'rw');
has partner_id => (is => 'rw');
has public_key => (is => 'rw');
has private_key => (is => 'rw');
has gateway => (is => 'ro', lazy => 1, default => sub { Net::Braintree::Gateway->new({config => shift})});
has environment => (
is => 'rw',
trigger => sub {
lib/Net/Braintree/Configuration.pm view on Meta::CPAN
if ($new_value !~ /integration|development|sandbox|production|qa/) {
warn "Assigned invalid value to Net::Braintree::Configuration::environment";
}
if ($new_value eq "integration") {
$self->public_key("integration_public_key");
$self->private_key("integration_private_key");
$self->merchant_id("integration_merchant_id");
}
}
);
view release on metacpan or search on metacpan
_Deparsed_XSubs.pm view on Meta::CPAN
sub COMP_add_compression_method($$);
sub CTX_add_client_CA($$);
sub CTX_add_extra_chain_cert($$);
sub CTX_add_session($$);
sub CTX_callback_ctrl($$$);
sub CTX_check_private_key($);
sub CTX_ctrl($$$$);
sub CTX_flush_sessions($$);
sub CTX_free($);
sub CTX_get0_param($);
sub CTX_get_app_data($);
_Deparsed_XSubs.pm view on Meta::CPAN
sub alert_desc_string($);
sub alert_desc_string_long($);
sub alert_type_string($);
sub alert_type_string_long($);
sub callback_ctrl($$$);
sub check_private_key($);
sub clear($);
sub clear_num_renegotiations($);
sub client_version($);
sub connect($);
sub constant($);
view release on metacpan or search on metacpan
lib/Net/DNS/SEC/Private.pm view on Meta::CPAN
The arguments define the private key parameters as (name,value) pairs.
The name and data representation are identical to that used in a BIND
private keyfile.
=head2 private_key_format
$format = $private->private_key_format;
Returns a string which identifies the format of the private key file.
=head2 algorithm, keytag, signame
view release on metacpan or search on metacpan
lib/Net/Domain/SMD/Schema.pm view on Meta::CPAN
my @w_opts;
if($cert)
{ push @w_opts
, token => $cert
, private_key => undef #XXX Work in progress
, publish_token => 'X509DATA'
, sign_info =>
{ sign_method => DSIGM_RSA_SHA256
# , private_key => $tmv_key
}
}
my $sig = XML::Compile::WSS::Signature->new
( schema => $schemas
view release on metacpan or search on metacpan
dropbear/ecc.c view on Meta::CPAN
}
/* a modified version of libtomcrypt's "ecc_shared_secret" to output
a mp_int instead. */
mp_int * dropbear_ecc_shared_secret(ecc_key *public_key, const ecc_key *private_key)
{
ecc_point *result = NULL;
mp_int *prime = NULL, *shared_secret = NULL;
int err = DROPBEAR_FAILURE;
/* type valid? */
if (private_key->type != PK_PRIVATE) {
goto out;
}
if (private_key->dp != public_key->dp) {
goto out;
}
/* make new point */
result = ltc_ecc_new_point();
dropbear/ecc.c view on Meta::CPAN
}
prime = m_malloc(sizeof(*prime));
m_mp_init(prime);
if (mp_read_radix(prime, (char *)private_key->dp->prime, 16) != CRYPT_OK) {
goto out;
}
if (ltc_mp.ecc_ptmul(private_key->k, &public_key->pubkey, result, prime, 1) != CRYPT_OK) {
goto out;
}
shared_secret = m_malloc(sizeof(*shared_secret));
m_mp_init(shared_secret);
view release on metacpan or search on metacpan
my $self = shift;
return undef if defined $self->{uid};
# openssl genrsa -out id_rsa 2048
my $pk = Crypt::OpenSSL::RSA->new_private_key(<<'PVT');
-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEA2VUahnbWKIY4rn8jEthY9M2BoMIHoNQlY4YUL9pV+MpSKyy9
MjVKV6h8ERnj+1wxUJDR3ZJimYnvcruGqlSR+uhL8MJs7GqSSOL3zKbZiHmip1/j
/9Wzsu86VJibxd14/5r8OugIJDs+aeE6fxpKW1BtUiiUAvlbC4MwnAnCPemzl7gG
qi64xsSaVdoi0NzZpxI+ItP9x89eMw64F5GlIviGJ9hODyW3ckKSvgxEQGf7x9TN
view release on metacpan or search on metacpan
"BH7LXCov0w51-y9i~BoB3g",
]
A private key (for inserting) can be constructed like this:
SSK@<private_key>,<crypto_key>/<name>
It can be used to insert data. The corresponding public key looks like this:
SSK@<public_key>PAgM,<crypto_key>/<name>
my ($self) = @_;
$self->txn ("generate_svk_pair");
});
=item $txn = $fcp->txn_invert_private_key ($private)
=item $public = $fcp->invert_private_key ($private)
Inverts a private key (returns the public key). C<$private> can be either
an insert URI (must start with C<freenet:SSK@>) or a raw private key (i.e.
the private value you get back from C<generate_svk_pair>).
Returns the public key.
=cut
$txn->(invert_private_key => sub {
my ($self, $privkey) = @_;
$self->txn (invert_private_key => private => $privkey);
});
=item $txn = $fcp->txn_get_size ($uri)
=item $length = $fcp->get_size ($uri)
key and the resulting public URI.
C<$meta> can be a hash reference (same format as returned by
C<Net::FCP::parse_metadata>) or a string.
The result is an arrayref with the keys C<uri>, C<public_key> and C<private_key>.
=cut
$txn->(client_put => sub {
my ($self, $uri, $metadata, $data, $htl, $removelocal) = @_;
use base Net::FCP::Txn;
sub rcv_success {
my ($self, $attr) = @_;
$self->set_result ([$attr->{public_key}, $attr->{private_key}, $attr->{crypto_key}]);
}
package Net::FCP::Txn::InvertPrivateKey;
use base Net::FCP::Txn;
view release on metacpan or search on metacpan
lib/Net/Google/AuthSub/Once.pm view on Meta::CPAN
use MIME::Base64;
sub new {
my ($klass, $options) = @_;
my $self = bless {}, $klass;
$self->{private_key_filename} = $options->{private_key_filename};
return $self;
}
sub get_authorization_url {
my ($self, $next_url) = @_;
lib/Net/Google/AuthSub/Once.pm view on Meta::CPAN
my $nonce = makerandom(Size => 64);
my $timestamp = time;
my $data = "GET $url $timestamp $nonce";
my $private_key = Crypt::OpenSSL::RSA->new_private_key(scalar read_file($self->{'private_key_filename'}));
my $sig = encode_base64($private_key->sign($data));
my $auth = qq{AuthSub token="$token" sigalg="rsa-sha1" data="$data" sig="$sig"};
$request->header('Authorization', $auth);
return;
lib/Net/Google/AuthSub/Once.pm view on Meta::CPAN
redirect_to($auth->get_authorization_url('http://example.com/your-next-url'));
# Then after the response comes back
# Make a request to the Google service
my $auth = Net::Google::AuthSub::Once->new({ private_key_filename => 'filename' });
my $request = HTTP::Request->new(GET => 'http://www.google.com/...');
$auth->sign_request($request);
my $resp = $ua->request($request);
=head1 DESCRIPTION
lib/Net/Google/AuthSub/Once.pm view on Meta::CPAN
=head2 CLASS->new($options)
=over 4
=item * private_key_filename
The filename of a private key file.
=back
view release on metacpan or search on metacpan
lib/Net/IPMessenger/Encrypt.pm view on Meta::CPAN
use strict;
use Net::IPMessenger::EncryptOption;
use base qw( Class::Accessor::Fast );
__PACKAGE__->mk_accessors(
qw( exponent modulus private_key
support_encryption attach )
);
my $RSA_KEY_SIZE = 1024;
my $IV = "\0\0\0\0\0\0\0\0";
lib/Net/IPMessenger/Encrypt.pm view on Meta::CPAN
}
sub generate_keys {
my $self = shift;
if ( $self->private_key ) {
return ( $self->exponent, $self->modulus );
}
my $rsa_key_size;
my $option = $self->support_encryption;
lib/Net/IPMessenger/Encrypt.pm view on Meta::CPAN
}
my $rsa = Crypt::OpenSSL::RSA->generate_key($rsa_key_size);
my( $modulus, $exponent ) = $rsa->get_key_parameters;
$self->private_key( $rsa->get_private_key_string );
return (
$self->exponent( $exponent->to_hex ),
$self->modulus( $modulus->to_hex )
);
}
lib/Net/IPMessenger/Encrypt.pm view on Meta::CPAN
unpack( "H*", $cipher_text );
}
sub decrypt_message {
my( $self, $message ) = @_;
return $message unless defined $self->private_key;
my( $enc_opt, $cipher_key, $cipher_text ) = split /\:/, $message, 3;
my $rsa = Crypt::OpenSSL::RSA->new_private_key( $self->private_key );
$rsa->use_pkcs1_padding;
my $shared_key = $rsa->decrypt( pack( "H*", $cipher_key ) );
my $blowfish = Crypt::CBC->new(
-literal_key => 1,
-key => $shared_key,
view release on metacpan or search on metacpan
src/ldns/host2str.c view on Meta::CPAN
status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k));
#ifndef S_SPLINT_S
ldns_buffer_printf(output, ")\n");
if(k->_key.key) {
EC_KEY* ec = EVP_PKEY_get1_EC_KEY(k->_key.key);
const BIGNUM* b = EC_KEY_get0_private_key(ec);
ldns_buffer_printf(output, "PrivateKey: ");
i = (uint16_t)BN_bn2bin(b, bignum);
if (i > LDNS_MAX_KEYLEN) {
goto error;
}
view release on metacpan or search on metacpan
lib/Net/Mollom.pm view on Meta::CPAN
{isa => 'Net::Mollom::Exception', fields => [qw(mollom_code mollom_desc)]},
);
has current_server => (is => 'rw', isa => 'Num', default => 0);
has public_key => (is => 'rw', isa => 'Str', required => 1);
has private_key => (is => 'rw', isa => 'Str', required => 1);
has session_id => (is => 'rw', isa => 'Str');
has xml_rpc => (is => 'rw', isa => 'XML::RPC');
has warnings => (is => 'rw', isa => 'Bool', default => 1);
has attempt_limit => (is => 'rw', isa => 'Num', default => 1);
has attempts => (is => 'rw', isa => 'Num', default => 0);
lib/Net/Mollom.pm view on Meta::CPAN
XML-RPC to determine whether user input is Spam, Ham, flame or
obscene.
my $mollom = Net::Mollom->new(
public_key => 'a2476604ffba00c907478c8f40b83b03',
private_key => '42d5448f124966e27db079c8fa92de0f',
);
my @server_list = $mollom->server_list();
my $check = $mollom->check_content(
lib/Net/Mollom.pm view on Meta::CPAN
=item * public_key (required)
This is your Mollom API public key.
=item * private_key (required)
This is your Mollom API private key.
=item * attempt_limit
lib/Net/Mollom.pm view on Meta::CPAN
return $self->_make_api_call('getStatistics', \%args);
}
sub _make_api_call {
my ($self, $function, $args) = @_;
my $secret = $self->private_key;
my @servers = @{$self->servers};
# keep track of how many times we've descended down into this rabbit hole
if( ! $self->{_recurse_level} ) {
$self->{_recurse_level} = 1;
view release on metacpan or search on metacpan
lib/Net/Nostr/KeyEncrypt.pm view on Meta::CPAN
use Unicode::Normalize qw(NFKC);
use Bitcoin::Crypto::Bech32 qw(encode_bech32 translate_5to8 translate_8to5);
use Exporter 'import';
our @EXPORT_OK = qw(
encrypt_private_key
decrypt_private_key
);
my $HEX64 = qr/\A[0-9a-f]{64}\z/;
my $VERSION_BYTE = 0x02;
my $MAX_BECH32_LENGTH = 5000;
lib/Net/Nostr/KeyEncrypt.pm view on Meta::CPAN
my @payload = @data_values[0 .. $#data_values - 6];
return ($hrp, \@payload);
}
}
sub encrypt_private_key {
my (%args) = @_;
my $privkey_hex = $args{privkey_hex} // croak "privkey_hex is required";
my $password = $args{password} // croak "password is required";
my $log_n = $args{log_n} // croak "log_n is required";
my $key_security = $args{key_security} // 0x02;
lib/Net/Nostr/KeyEncrypt.pm view on Meta::CPAN
my $data5 = translate_8to5($raw);
return encode_bech32('ncryptsec', $data5, 'bech32');
}
sub decrypt_private_key {
my ($ncryptsec, $password, %opts) = @_;
croak "ncryptsec string is required" unless defined $ncryptsec && length $ncryptsec;
croak "password is required" unless defined $password && length $password;
lib/Net/Nostr/KeyEncrypt.pm view on Meta::CPAN
Net::Nostr::KeyEncrypt - NIP-49 private key encryption
=head1 SYNOPSIS
use Net::Nostr::KeyEncrypt qw(encrypt_private_key decrypt_private_key);
# Encrypt a private key with a password
my $ncryptsec = encrypt_private_key(
privkey_hex => 'aa' x 32,
password => 'my-strong-password',
log_n => 16,
);
# ncryptsec1...
# Decrypt an encrypted private key
my $privkey_hex = decrypt_private_key($ncryptsec, 'my-strong-password');
# 'aa' x 32
# Specify key security level
my $ncryptsec = encrypt_private_key(
privkey_hex => $privkey_hex,
password => $password,
log_n => 20,
key_security => 0x01, # not known to have been handled insecurely
);
lib/Net/Nostr/KeyEncrypt.pm view on Meta::CPAN
=head1 FUNCTIONS
All functions are exportable. None are exported by default.
=head2 encrypt_private_key
my $ncryptsec = encrypt_private_key(
privkey_hex => $hex_privkey,
password => $password,
log_n => $log_n,
key_security => $byte, # optional, defaults to 0x02
);
lib/Net/Nostr/KeyEncrypt.pm view on Meta::CPAN
Defaults to C<0x02>. This byte is included as associated data in the
AEAD encryption and stored in the payload.
=back
my $ncryptsec = encrypt_private_key(
privkey_hex => 'aa' x 32,
password => 'my-strong-password',
log_n => 16,
);
=head2 decrypt_private_key
my $hex = decrypt_private_key($ncryptsec, $password);
my $hex = decrypt_private_key($ncryptsec, $password, log_n => $n);
Decrypts an C<ncryptsec> string with a password. Returns the private key
as a 64-char lowercase hex string. Validates the bech32 encoding,
C<ncryptsec> prefix, version byte (must be C<0x02>), and payload size
(must be 91 bytes). Croaks on wrong password, corrupted data, or
lib/Net/Nostr/KeyEncrypt.pm view on Meta::CPAN
The C<log_n> parameter is optional. If omitted, the value embedded in
the C<ncryptsec> payload is used. Providing C<log_n> explicitly overrides
the embedded value, which is useful when you know the cost parameter
in advance.
my $hex = decrypt_private_key(
'ncryptsec1qgg9947rlpvqu76pj5ecreduf9jxhselq2nae2kghhvd5g7dgjtcxfqtd67p9m0w57lspw8gsq6yphnm8623nsl8xn9j4jdzz84zm3frztj3z7s35vpzmqf6ksu8r89qk5z2zxfmu5gv8th8wclt0h4p',
'nostr',
);
# '3501454135014541350145413501453fefb02227e449e57cf4d3a3ce05378683'
view release on metacpan or search on metacpan
lib/Net/OAuth.pm view on Meta::CPAN
Consumer:
use Crypt::OpenSSL::RSA;
use File::Slurp;
$keystring = read_file('private_key.pem');
$private_key = Crypt::OpenSSL::RSA->new_private_key($keystring);
$request = Net::OAuth->request('request token')->new(%params);
$request->sign($private_key);
Service Provider:
use Crypt::OpenSSL::RSA;
use File::Slurp;
view release on metacpan or search on metacpan
* basic support for OpenID extensions (2006-03-13)
0.10: (2005-09-01)
* fix up old docs which mentioned the ancient public_key and
private_key parameters
* fix some warnings in make test. (Tatsuhiko Miyagawa)
0.09:
* version 1.1 of the protocol, with 1.0 as a "compat" option
view release on metacpan or search on metacpan
lib/Net/OpenSSH.pm view on Meta::CPAN
=item passphrase => $passphrase
X<passphrase>Uses given passphrase to open private key.
=item key_path => $private_key_path
Uses the key stored on the given file path for authentication.
=item gateway => $gateway
view release on metacpan or search on metacpan
lib/Net/SPID/SAML.pm view on Meta::CPAN
sub _build_sp_key {
my ($self) = @_;
my $key_string = read_file($self->sp_key_file);
my $key = Crypt::OpenSSL::RSA->new_private_key($key_string);
$key->use_sha256_hash;
return $key;
}
sub _build_sp_cert {
view release on metacpan or search on metacpan
lib/Net/SSH/Any/Test.pm view on Meta::CPAN
=item password => $password
Sets the SSH password.
=item key_path => $private_key_path
=item key_paths => \@private_key_paths
Path to files containing private keys to use for authentication.
=item backend_opts => { $backend_name => \%opts, ... }
view release on metacpan or search on metacpan
lib/Net/SSH/Perl/Auth/RSA.pm view on Meta::CPAN
sub _authenticate {
my($auth, $auth_file) = @_;
my $ssh = $auth->{ssh};
my($packet);
my($public_key, $comment, $private_key);
eval {
($public_key, $comment) = _load_public_key($auth_file);
};
$ssh->debug("RSA authentication failed: Can't load public key."),
return 0 if $@;
lib/Net/SSH/Perl/Auth/RSA.pm view on Meta::CPAN
my $challenge = $packet->get_mp_int;
$ssh->debug("Received RSA challenge from server.");
eval {
$private_key = _load_private_key($auth_file, "");
};
if (!$private_key || $@) {
my $passphrase = "";
if ($ssh->config->get('interactive')) {
$passphrase = _read_passphrase("Enter passphrase for RSA key '$comment': ");
}
else {
$ssh->debug("Will not query passphrase for '$comment' in batch mode.");
}
eval {
$private_key = _load_private_key($auth_file, $passphrase);
};
if (!$private_key || $@) {
$ssh->debug("Loading private key failed: $@.");
$packet = $ssh->packet_start(SSH_CMSG_AUTH_RSA_RESPONSE);
$packet->put_char(0) for (1..16);
$packet->send;
Net::SSH::Perl::Packet->read_expect($ssh, SSH_SMSG_FAILURE);
return 0;
}
}
_respond_to_rsa_challenge($ssh, $challenge, $private_key);
$packet = Net::SSH::Perl::Packet->read($ssh);
my $type = $packet->type;
if ($type == SSH_SMSG_SUCCESS) {
$ssh->debug("RSA authentication accepted by server.");
view release on metacpan or search on metacpan
lib/Net/SSLeay/OO/Context.pm view on Meta::CPAN
sess_cache_full(ctx)
sess_get_cache_size(ctx)
sess_set_cache_size(ctx,size)
add_client_CA(ctx,x)
callback_ctrl(ctx,i,fp)
check_private_key(ctx)
get_ex_data(ssl,idx)
get_quiet_shutdown(ctx)
get_timeout(ctx)
get_verify_depth(ctx)
get_verify_mode(ctx)
view release on metacpan or search on metacpan
lib/Net/SSLeay.pm view on Meta::CPAN
NID_pkcs9_extCertAttributes
NID_pkcs9_messageDigest
NID_pkcs9_signingTime
NID_pkcs9_unstructuredAddress
NID_pkcs9_unstructuredName
NID_private_key_usage_period
NID_rc2_40_cbc
NID_rc2_64_cbc
NID_rc2_cbc
NID_rc2_cfb64
NID_rc2_ecb
view release on metacpan or search on metacpan
lib/Net/SAML2/Binding/Redirect.pm view on Meta::CPAN
$u->query_param($self->param, $req);
$u->query_param('RelayState', $relaystate) if defined $relaystate;
$u->query_param('SigAlg', 'http://www.w3.org/2000/09/xmldsig#rsa-sha1');
my $key_string = read_file($self->key);
my $rsa_priv = Crypt::OpenSSL::RSA->new_private_key($key_string);
my $to_sign = $u->query;
my $sig = encode_base64($rsa_priv->sign($to_sign), '');
$u->query_param('Signature', $sig);
view release on metacpan or search on metacpan
lib/Net/Simplify.pm view on Meta::CPAN
use Net::Simplify;
# Set global API keys
$Net::Simplify::public_key = 'YOUR PUBLIC KEY';
$Net::Simplify::private_key = 'YOUR PRIVATE KEY';
# Create a payment
my $payment = Net::Simplify::Payment->create({
amount => 1200,
currency => 'USD',
lib/Net/Simplify.pm view on Meta::CPAN
# Use an Authentication object to hold credentials
my $auth = Net::Simplify::Authentication->create({
public_key => 'YOUR PUBLIC KEY',
private_key => 'YOUR PRIVATE_KEY'
};
# Create a payment using the $auth object
my $payment2 = Net::Simplify::Payment->create({
amount => 2400,
lib/Net/Simplify.pm view on Meta::CPAN
=head3 $Net::Simplify::public_key
The public key to be used for all API calls where an Authentication object is not passed.
=head3 $Net::Simplify::private_key
The private key to be used for all API calls where an Authentication object is not passed.
=head3 $Net::Simplify::user_agent
lib/Net/Simplify.pm view on Meta::CPAN
use warnings FATAL => 'all';
use Net::Simplify::Constants;
$Net::Simplify::public_key = undef;
$Net::Simplify::private_key = undef;
$Net::Simplify::api_base_live_url = $Net::Simplify::Constants::API_BASE_LIVE_URL;
$Net::Simplify::api_base_sandbox_url = $Net::Simplify::Constants::API_BASE_SANDBOX_URL;
$Net::Simplify::oauth_base_url = $Net::Simplify::Constants::OAUTH_BASE_URL;
$Net::Simplify::user_agent = undef;
view release on metacpan or search on metacpan
lib/Net/Wireless/802_11/AP.pm view on Meta::CPAN
anonymous_identity=>undef,
mixed_cell=>undef,
password=>undef,
ca_cert=>undef,
client_cert=>undef,
private_key=>undef,
private_key_passwd=>undef,
dh_file=>undef,
subject_match=>undef,
phase1=>undef,
phase2=>undef,
ca_cert2=>undef,
client_cert2=>undef,
private_key2=>undef,
private_key2_passwd=>undef,
dh_file2=>undef,
subject_match2=>undef,
eappsk=>undef,
nai=>undef,
server_nai=>undef,
lib/Net/Wireless/802_11/AP.pm view on Meta::CPAN
anonymous_identity=>1,
mixed_cell=>1,
password=>1,
ca_cert=>1,
client_cert=>1,
private_key=>1,
private_key_passwd=>1,
dh_file=>1,
subject_match=>1,
phase1=>1,
phase2=>1,
ca_cert2=>1,
client_cert2=>1,
private_key2=>1,
private_key2_passwd=>1,
dh_file2=>1,
subject_match2=>1,
eappsk=>1,
nai=>1,
server_nai=>1,
lib/Net/Wireless/802_11/AP.pm view on Meta::CPAN
anonymous_identity=>1,
mixed_cell=>1,
password=>1,
ca_cert=>1,
client_cert=>1,
private_key=>1,
private_key_passwd=>1,
dh_file=>1,
subject_match=>1,
phase1=>1,
phase2=>1,
ca_cert2=>1,
client_cert2=>1,
private_key2=>1,
private_key2_passwd=>1,
dh_file2=>1,
subject_match2=>1,
eappsk=>1,
nai=>1,
server_nai=>1,
view release on metacpan or search on metacpan
lib/Net/Xero.pm view on Meta::CPAN
timestamp => time,
nonce => $self->nonce,
callback => $self->callback_url,
);
my $private_key = Crypt::OpenSSL::RSA->new_private_key($self->cert);
$request->sign($private_key);
my $res = $self->ua->request(GET $request->to_url);
if ($res->is_success) {
my $response =
Net::OAuth->response('request token')
lib/Net/Xero.pm view on Meta::CPAN
nonce => $self->nonce,
callback => $self->callback_url,
token => $self->request_token,
token_secret => $self->request_secret,
);
my $private_key = Crypt::OpenSSL::RSA->new_private_key($self->cert);
$request->sign($private_key);
my $res = $self->ua->request(GET $request->to_url);
if ($res->is_success) {
my $response =
Net::OAuth->response('access token')->from_post_body($res->content);
lib/Net/Xero.pm view on Meta::CPAN
$content = $self->_template($hash);
$opts{extra_params} = { xml => $content } if ($method eq 'POST');
}
my $request = Net::OAuth->request("protected resource")->new(%opts);
my $private_key = Crypt::OpenSSL::RSA->new_private_key($self->cert);
$request->sign($private_key);
#my $req = HTTP::Request->new($method, $request->to_url);
my $req = HTTP::Request->new($method, $request_url);
if ($hash and ($method eq 'POST')) {
$req->content($request->to_post_body);
$req->header('Content-Type' =>
view release on metacpan or search on metacpan
src/event/ngx_event_openssl.c view on Meta::CPAN
return NGX_ERROR;
}
*last++ = ':';
pkey = ENGINE_load_private_key(engine, (char *) last, 0, 0);
if (pkey == NULL) {
ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
"ENGINE_load_private_key(\"%s\") failed", last);
ENGINE_free(engine);
return NGX_ERROR;
}
ENGINE_free(engine);
view release on metacpan or search on metacpan
examples/generate_rsa_keys.pl view on Meta::CPAN
my $rsa = Crypt::OpenSSL::RSA->generate_key(1024);
say $rsa->get_public_key_string();
say $rsa->get_private_key_string();
view release on metacpan or search on metacpan
lib/OIDC/Client.pm view on Meta::CPAN
=cut
enum 'StoreMode' => [qw/session stash cache/];
enum 'ResponseMode' => [qw/query form_post/];
enum 'GrantType' => [qw/authorization_code client_credentials password refresh_token/];
enum 'ClientAuthMethod' => [qw/client_secret_basic client_secret_post client_secret_jwt private_key_jwt none/];
enum 'TokenValidationMethod' => [qw/jwt introspection/];
with 'OIDC::Client::Role::LoggerWrapper';
with 'OIDC::Client::Role::AttributesManager';
with 'OIDC::Client::Role::ConfigurationChecker';
lib/OIDC/Client.pm view on Meta::CPAN
client_secret_jwt
=item *
private_key_jwt
=item *
none
lib/OIDC/Client.pm view on Meta::CPAN
client_secret_jwt
=item *
private_key_jwt
=item *
none
lib/OIDC/Client.pm view on Meta::CPAN
client_secret_jwt
=item *
private_key_jwt
=item *
none
view release on metacpan or search on metacpan
t/WrapScope/ConfigGenerator/sample_tree/Secret/Encryption.pm view on Meta::CPAN
package Secret::Encryption;
sub get_private_keys { }
sub hash { }
1;