INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Generates an RSA DSA or ECDSA signature via CNG | def _bcrypt_sign(private_key, data, hash_algorithm, rsa_pss_padding=False):
"""
Generates an RSA, DSA or ECDSA signature via CNG
:param private_key:
The PrivateKey to generate the signature with
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
... |
Encrypts a value using an RSA public key | def _encrypt(certificate_or_public_key, data, rsa_oaep_padding=False):
"""
Encrypts a value using an RSA public key
:param certificate_or_public_key:
A Certificate or PublicKey instance to encrypt with
:param data:
A byte string of the data to encrypt
:param rsa_oaep_padding:
... |
Encrypts a value using an RSA public key via CryptoAPI | def _advapi32_encrypt(certificate_or_public_key, data, rsa_oaep_padding=False):
"""
Encrypts a value using an RSA public key via CryptoAPI
:param certificate_or_public_key:
A Certificate or PublicKey instance to encrypt with
:param data:
A byte string of the data to encrypt
:param... |
Encrypts a value using an RSA public key via CNG | def _bcrypt_encrypt(certificate_or_public_key, data, rsa_oaep_padding=False):
"""
Encrypts a value using an RSA public key via CNG
:param certificate_or_public_key:
A Certificate or PublicKey instance to encrypt with
:param data:
A byte string of the data to encrypt
:param rsa_oae... |
Encrypts a value using an RSA private key | def _decrypt(private_key, ciphertext, rsa_oaep_padding=False):
"""
Encrypts a value using an RSA private key
:param private_key:
A PrivateKey instance to decrypt with
:param ciphertext:
A byte string of the data to decrypt
:param rsa_oaep_padding:
If OAEP padding should be... |
Encrypts a value using an RSA private key via CryptoAPI | def _advapi32_decrypt(private_key, ciphertext, rsa_oaep_padding=False):
"""
Encrypts a value using an RSA private key via CryptoAPI
:param private_key:
A PrivateKey instance to decrypt with
:param ciphertext:
A byte string of the data to decrypt
:param rsa_oaep_padding:
If... |
: return: A boolean - if the certificate is self - signed | def self_signed(self):
"""
:return:
A boolean - if the certificate is self-signed
"""
if self._self_signed is None:
self._self_signed = False
if self.asn1.self_signed in set(['yes', 'maybe']):
signature_algo = self.asn1['signature_alg... |
Obtains a credentials handle from secur32. dll for use with SChannel | def _obtain_credentials(self):
"""
Obtains a credentials handle from secur32.dll for use with SChannel
"""
protocol_values = {
'SSLv3': Secur32Const.SP_PROT_SSL3_CLIENT,
'TLSv1': Secur32Const.SP_PROT_TLS1_CLIENT,
'TLSv1.1': Secur32Const.SP_PROT_TLS1_1... |
Takes an existing socket and adds TLS | def wrap(cls, socket, hostname, session=None):
"""
Takes an existing socket and adds TLS
:param socket:
A socket.socket object to wrap with TLS
:param hostname:
A unicode string of the hostname or IP the socket is connected to
:param session:
... |
Creates a SecBufferDesc struct and contained SecBuffer structs | def _create_buffers(self, number):
"""
Creates a SecBufferDesc struct and contained SecBuffer structs
:param number:
The number of contains SecBuffer objects to create
:return:
A tuple of (SecBufferDesc pointer, SecBuffer array)
"""
buffers = ne... |
Manually invoked windows certificate chain builder and verification step when there are extra trust roots to include in the search process | def _extra_trust_root_validation(self):
"""
Manually invoked windows certificate chain builder and verification
step when there are extra trust roots to include in the search process
"""
store = None
cert_chain_context_pointer = None
try:
# We set up... |
Perform an initial TLS handshake or a renegotiation | def _handshake(self, renegotiate=False):
"""
Perform an initial TLS handshake, or a renegotiation
:param renegotiate:
If the handshake is for a renegotiation
"""
in_buffers = None
out_buffers = None
new_context_handle_pointer = None
try:
... |
Reads data from the TLS - wrapped socket | def read(self, max_length):
"""
Reads data from the TLS-wrapped socket
:param max_length:
The number of bytes to read
:raises:
socket.socket - when a non-TLS socket error occurs
oscrypto.errors.TLSError - when a TLS-related error occurs
V... |
Blocks until the socket is ready to be read from or the timeout is hit | def select_read(self, timeout=None):
"""
Blocks until the socket is ready to be read from, or the timeout is hit
:param timeout:
A float - the period of time to wait for data to be read. None for
no time limit.
:return:
A boolean - if data is ready t... |
Reads exactly the specified number of bytes from the socket | def read_exactly(self, num_bytes):
"""
Reads exactly the specified number of bytes from the socket
:param num_bytes:
An integer - the exact number of bytes to read
:return:
A byte string of the data that was read
"""
output = b''
remaini... |
Writes data to the TLS - wrapped socket | def write(self, data):
"""
Writes data to the TLS-wrapped socket
:param data:
A byte string to write to the socket
:raises:
socket.socket - when a non-TLS socket error occurs
oscrypto.errors.TLSError - when a TLS-related error occurs
Valu... |
Blocks until the socket is ready to be written to or the timeout is hit | def select_write(self, timeout=None):
"""
Blocks until the socket is ready to be written to, or the timeout is hit
:param timeout:
A float - the period of time to wait for the socket to be ready to
written to. None for no time limit.
:return:
A boole... |
Shuts down the TLS session and then shuts down the underlying socket | def shutdown(self):
"""
Shuts down the TLS session and then shuts down the underlying socket
:raises:
OSError - when an error is returned by the OS crypto library
"""
if self._context_handle_pointer is None:
return
out_buffers = None
try... |
Shuts down the TLS session and socket and forcibly closes it | def close(self):
"""
Shuts down the TLS session and socket and forcibly closes it
"""
try:
self.shutdown()
finally:
if self._socket:
try:
self._socket.close()
except (socket_.error):
... |
Reads end - entity and intermediate certificate information from the TLS session | def _read_certificates(self):
"""
Reads end-entity and intermediate certificate information from the
TLS session
"""
cert_context_pointer_pointer = new(crypt32, 'CERT_CONTEXT **')
result = secur32.QueryContextAttributesW(
self._context_handle_pointer,
... |
An asn1crypto. x509. Certificate object of the end - entity certificate presented by the server | def certificate(self):
"""
An asn1crypto.x509.Certificate object of the end-entity certificate
presented by the server
"""
if self._context_handle_pointer is None:
self._raise_closed()
if self._certificate is None:
self._read_certificates()
... |
A list of asn1crypto. x509. Certificate objects that were presented as intermediates by the server | def intermediates(self):
"""
A list of asn1crypto.x509.Certificate objects that were presented as
intermediates by the server
"""
if self._context_handle_pointer is None:
self._raise_closed()
if self._certificate is None:
self._read_certificates(... |
Checks a CFErrorRef and throws an exception if there is an error to report | def handle_cf_error(error_pointer):
"""
Checks a CFErrorRef and throws an exception if there is an error to report
:param error_pointer:
A CFErrorRef
:raises:
OSError - when the CFErrorRef contains an error
"""
if is_null(error_pointer):
return
error = unwrap(erro... |
Takes an existing socket and adds TLS | def wrap(cls, socket, hostname, session=None):
"""
Takes an existing socket and adds TLS
:param socket:
A socket.socket object to wrap with TLS
:param hostname:
A unicode string of the hostname or IP the socket is connected to
:param session:
... |
Perform an initial TLS handshake | def _handshake(self):
"""
Perform an initial TLS handshake
"""
self._ssl = None
self._rbio = None
self._wbio = None
try:
self._ssl = libssl.SSL_new(self._session._ssl_ctx)
if is_null(self._ssl):
self._ssl = None
... |
Reads data from the socket and writes it to the memory bio used by libssl to decrypt the data. Returns the unencrypted data for the purpose of debugging handshakes. | def _raw_read(self):
"""
Reads data from the socket and writes it to the memory bio
used by libssl to decrypt the data. Returns the unencrypted
data for the purpose of debugging handshakes.
:return:
A byte string of ciphertext from the socket. Used for
de... |
Takes ciphertext from the memory bio and writes it to the socket. | def _raw_write(self):
"""
Takes ciphertext from the memory bio and writes it to the
socket.
:return:
A byte string of ciphertext going to the socket. Used
for debugging the handshake only.
"""
data_available = libssl.BIO_ctrl_pending(self._wbio)
... |
Reads data from the TLS - wrapped socket | def read(self, max_length):
"""
Reads data from the TLS-wrapped socket
:param max_length:
The number of bytes to read - output may be less than this
:raises:
socket.socket - when a non-TLS socket error occurs
oscrypto.errors.TLSError - when a TLS-rel... |
Writes data to the TLS - wrapped socket | def write(self, data):
"""
Writes data to the TLS-wrapped socket
:param data:
A byte string to write to the socket
:raises:
socket.socket - when a non-TLS socket error occurs
oscrypto.errors.TLSError - when a TLS-related error occurs
Valu... |
Shuts down the TLS session and then shuts down the underlying socket | def _shutdown(self, manual):
"""
Shuts down the TLS session and then shuts down the underlying socket
:param manual:
A boolean if the connection was manually shutdown
"""
if self._ssl is None:
return
while True:
result = libssl.SSL_s... |
Reads end - entity and intermediate certificate information from the TLS session | def _read_certificates(self):
"""
Reads end-entity and intermediate certificate information from the
TLS session
"""
stack_pointer = libssl.SSL_get_peer_cert_chain(self._ssl)
if is_null(stack_pointer):
handle_openssl_error(0, TLSError)
if libcrypto_v... |
An asn1crypto. x509. Certificate object of the end - entity certificate presented by the server | def certificate(self):
"""
An asn1crypto.x509.Certificate object of the end-entity certificate
presented by the server
"""
if self._ssl is None:
self._raise_closed()
if self._certificate is None:
self._read_certificates()
return self._ce... |
A list of asn1crypto. x509. Certificate objects that were presented as intermediates by the server | def intermediates(self):
"""
A list of asn1crypto.x509.Certificate objects that were presented as
intermediates by the server
"""
if self._ssl is None:
self._raise_closed()
if self._certificate is None:
self._read_certificates()
return s... |
Encrypts plaintext using AES in CBC mode with a 128 192 or 256 bit key and no padding. This means the ciphertext must be an exact multiple of 16 bytes long. | def aes_cbc_no_padding_encrypt(key, data, iv):
"""
Encrypts plaintext using AES in CBC mode with a 128, 192 or 256 bit key and
no padding. This means the ciphertext must be an exact multiple of 16 bytes
long.
:param key:
The encryption key - a byte string either 16, 24 or 32 bytes long
... |
Decrypts AES ciphertext in CBC mode using a 128 192 or 256 bit key and no padding. | def aes_cbc_no_padding_decrypt(key, data, iv):
"""
Decrypts AES ciphertext in CBC mode using a 128, 192 or 256 bit key and no
padding.
:param key:
The encryption key - a byte string either 16, 24 or 32 bytes long
:param data:
The ciphertext - a byte string
:param iv:
T... |
Encrypts plaintext using 3DES in either 2 or 3 key mode | def tripledes_cbc_pkcs5_encrypt(key, data, iv):
"""
Encrypts plaintext using 3DES in either 2 or 3 key mode
:param key:
The encryption key - a byte string 16 or 24 bytes long (2 or 3 key mode)
:param data:
The plaintext - a byte string
:param iv:
The 8-byte initialization ... |
Creates an HCRYPTPROV and HCRYPTKEY for symmetric encryption/ decryption. The HCRYPTPROV must be released by close_context_handle () and the HCRYPTKEY must be released by advapi32. CryptDestroyKey () when done. | def _advapi32_create_handles(cipher, key, iv):
"""
Creates an HCRYPTPROV and HCRYPTKEY for symmetric encryption/decryption. The
HCRYPTPROV must be released by close_context_handle() and the
HCRYPTKEY must be released by advapi32.CryptDestroyKey() when done.
:param cipher:
A unicode string o... |
Creates a BCRYPT_KEY_HANDLE for symmetric encryption/ decryption. The handle must be released by bcrypt. BCryptDestroyKey () when done. | def _bcrypt_create_key_handle(cipher, key):
"""
Creates a BCRYPT_KEY_HANDLE for symmetric encryption/decryption. The
handle must be released by bcrypt.BCryptDestroyKey() when done.
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:pa... |
Encrypts plaintext | def _encrypt(cipher, key, data, iv, padding):
"""
Encrypts plaintext
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
The plaintext - a byte... |
Encrypts plaintext via CryptoAPI | def _advapi32_encrypt(cipher, key, data, iv, padding):
"""
Encrypts plaintext via CryptoAPI
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
... |
Encrypts plaintext via CNG | def _bcrypt_encrypt(cipher, key, data, iv, padding):
"""
Encrypts plaintext via CNG
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
The pla... |
Decrypts AES/ RC4/ RC2/ 3DES/ DES ciphertext | def _decrypt(cipher, key, data, iv, padding):
"""
Decrypts AES/RC4/RC2/3DES/DES ciphertext
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:param key:
The encryption key - a byte string 5-16 bytes long
:param data:
... |
Decrypts AES/ RC4/ RC2/ 3DES/ DES ciphertext via CryptoAPI | def _advapi32_decrypt(cipher, key, data, iv, padding):
"""
Decrypts AES/RC4/RC2/3DES/DES ciphertext via CryptoAPI
:param cipher:
A unicode string of "aes", "des", "tripledes_2key", "tripledes_3key",
"rc2", "rc4"
:param key:
The encryption key - a byte string 5-16 bytes long
... |
Extracts the last Windows error message into a python unicode string | def handle_error(error_num):
"""
Extracts the last Windows error message into a python unicode string
:param error_num:
The number to get the error string for
:return:
A unicode string error message
"""
if error_num == 0:
return
messages = {
BcryptConst.ST... |
Checks if an error occured and if so throws an OSError containing the last OpenSSL error message | def handle_openssl_error(result, exception_class=None):
"""
Checks if an error occured, and if so throws an OSError containing the
last OpenSSL error message
:param result:
An integer result code - 1 or greater indicates success
:param exception_class:
The exception class to use fo... |
Peeks into the error stack and pulls out the lib func and reason | def peek_openssl_error():
"""
Peeks into the error stack and pulls out the lib, func and reason
:return:
A three-element tuple of integers (lib, func, reason)
"""
error = libcrypto.ERR_peek_error()
lib = int((error >> 24) & 0xff)
func = int((error >> 12) & 0xfff)
reason = int(e... |
: return: A bool if the current machine is running OS X 10. 7 | def _is_osx_107():
"""
:return:
A bool if the current machine is running OS X 10.7
"""
if sys.platform != 'darwin':
return False
version = platform.mac_ver()[0]
return tuple(map(int, version.split('.')))[0:2] == (10, 7) |
Pads a byte string using the EMSA - PSS - Encode operation described in PKCS#1 v2. 2. | def add_pss_padding(hash_algorithm, salt_length, key_length, message):
"""
Pads a byte string using the EMSA-PSS-Encode operation described in PKCS#1
v2.2.
:param hash_algorithm:
The string name of the hash algorithm to use: "sha1", "sha224",
"sha256", "sha384", "sha512"
:param sal... |
Verifies the PSS padding on an encoded message | def verify_pss_padding(hash_algorithm, salt_length, key_length, message, signature):
"""
Verifies the PSS padding on an encoded message
:param hash_algorithm:
The string name of the hash algorithm to use: "sha1", "sha224",
"sha256", "sha384", "sha512"
:param salt_length:
The le... |
The PKCS#1 MGF1 mask generation algorithm | def _mgf1(hash_algorithm, seed, mask_length):
"""
The PKCS#1 MGF1 mask generation algorithm
:param hash_algorithm:
The string name of the hash algorithm to use: "sha1", "sha224",
"sha256", "sha384", "sha512"
:param seed:
A byte string to use as the seed for the mask
:param... |
Adds PKCS#1 v1. 5 padding to a message | def _add_pkcs1v15_padding(key_length, data, operation):
"""
Adds PKCS#1 v1.5 padding to a message
:param key_length:
An integer of the number of bytes in the key
:param data:
A byte string to unpad
:param operation:
A unicode string of "encrypting" or "signing"
:retur... |
Removes PKCS#1 v1. 5 padding from a message using constant time operations | def _remove_pkcs1v15_padding(key_length, data, operation):
"""
Removes PKCS#1 v1.5 padding from a message using constant time operations
:param key_length:
An integer of the number of bytes in the key
:param data:
A byte string to unpad
:param operation:
A unicode string o... |
Performs a raw RSA algorithm in a byte string using a private key. This is a low - level primitive and is prone to disastrous results if used incorrectly. | def raw_rsa_private_crypt(private_key, data):
"""
Performs a raw RSA algorithm in a byte string using a private key.
This is a low-level primitive and is prone to disastrous results if used
incorrectly.
:param private_key:
An oscrypto.asymmetric.PrivateKey object
:param data:
A... |
Performs a raw RSA algorithm in a byte string using a certificate or public key. This is a low - level primitive and is prone to disastrous results if used incorrectly. | def raw_rsa_public_crypt(certificate_or_public_key, data):
"""
Performs a raw RSA algorithm in a byte string using a certificate or
public key. This is a low-level primitive and is prone to disastrous results
if used incorrectly.
:param certificate_or_public_key:
An oscrypto.asymmetric.Publ... |
KDF from RFC7292 appendix B. 2 - https:// tools. ietf. org/ html/ rfc7292#page - 19 | def pkcs12_kdf(hash_algorithm, password, salt, iterations, key_length, id_):
"""
KDF from RFC7292 appendix B.2 - https://tools.ietf.org/html/rfc7292#page-19
:param hash_algorithm:
The string name of the hash algorithm to use: "md5", "sha1", "sha224", "sha256", "sha384", "sha512"
:param passwor... |
Extracts trusted CA certificates from the OS X trusted root keychain. | def extract_from_system(cert_callback=None, callback_only_on_failure=False):
"""
Extracts trusted CA certificates from the OS X trusted root keychain.
:param cert_callback:
A callback that is called once for each certificate in the trust store.
It should accept two parameters: an asn1crypto... |
Constructs an asn1crypto. x509. Certificate object and calls the export callback | def _cert_callback(callback, der_cert, reason):
"""
Constructs an asn1crypto.x509.Certificate object and calls the export
callback
:param callback:
The callback to call
:param der_cert:
A byte string of the DER-encoded certificate
:param reason:
None if cert is being e... |
Return the certificate and a hash of it | def _cert_details(cert_pointer):
"""
Return the certificate and a hash of it
:param cert_pointer:
A SecCertificateRef
:return:
A 2-element tuple:
- [0]: A byte string of the SHA1 hash of the cert
- [1]: A byte string of the DER-encoded contents of the cert
"""
... |
Extracts the last OS error message into a python unicode string | def _extract_error():
"""
Extracts the last OS error message into a python unicode string
:return:
A unicode string error message
"""
error_num = errno()
try:
error_string = os.strerror(error_num)
except (ValueError):
return str_cls(error_num)
if isinstance(er... |
PBKDF2 from PKCS#5 | def pbkdf2(hash_algorithm, password, salt, iterations, key_length):
"""
PBKDF2 from PKCS#5
:param hash_algorithm:
The string name of the hash algorithm to use: "sha1", "sha224", "sha256", "sha384", "sha512"
:param password:
A byte string of the password to use an input to the KDF
... |
Returns a number of random bytes suitable for cryptographic purposes | def rand_bytes(length):
"""
Returns a number of random bytes suitable for cryptographic purposes
:param length:
The desired number of bytes
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the parameters are of the wrong type
... |
Converts a CFNumber object to a python float or integer | def cf_number_to_number(value):
"""
Converts a CFNumber object to a python float or integer
:param value:
The CFNumber object
:return:
A python number (float or integer)
"""
type_ = CoreFoundation.CFNumberGetType(_cast_pointer_p(value))
... |
Converts a CFDictionary object into a python dictionary | def cf_dictionary_to_dict(dictionary):
"""
Converts a CFDictionary object into a python dictionary
:param dictionary:
The CFDictionary to convert
:return:
A python dict
"""
dict_length = CoreFoundation.CFDictionaryGetCount(dictionary)
k... |
Converts a CF * object into its python equivalent | def native(cls, value):
"""
Converts a CF* object into its python equivalent
:param value:
The CF* object to convert
:return:
The native python object
"""
type_id = CoreFoundation.CFGetTypeID(value)
if type_id in cls._native_map:
... |
Creates a python unicode string from a CFString object | def cf_string_to_unicode(value):
"""
Creates a python unicode string from a CFString object
:param value:
The CFString to convert
:return:
A python unicode string
"""
string = CoreFoundation.CFStringGetCStringPtr(
_cast_pointer_p(val... |
Extracts a bytestring from a CFData object | def cf_data_to_bytes(value):
"""
Extracts a bytestring from a CFData object
:param value:
A CFData object
:return:
A byte string
"""
start = CoreFoundation.CFDataGetBytePtr(value)
num_bytes = CoreFoundation.CFDataGetLength(value)
... |
Creates a CFDictionaryRef object from a list of 2 - element tuples representing the key and value. Each key should be a CFStringRef and each value some sort of CF * type. | def cf_dictionary_from_pairs(pairs):
"""
Creates a CFDictionaryRef object from a list of 2-element tuples
representing the key and value. Each key should be a CFStringRef and each
value some sort of CF* type.
:param pairs:
A list of 2-element tuples
:return:... |
Creates a CFArrayRef object from a list of CF * type objects. | def cf_array_from_list(values):
"""
Creates a CFArrayRef object from a list of CF* type objects.
:param values:
A list of CF* type object
:return:
A CFArrayRef
"""
length = len(values)
values = (CFTypeRef * length)(*values)
retur... |
Creates a CFNumber object from an integer | def cf_number_from_integer(integer):
"""
Creates a CFNumber object from an integer
:param integer:
The integer to create the CFNumber for
:return:
A CFNumber
"""
integer_as_long = c_long(integer)
return CoreFoundation.CFNumberCreate(
... |
Converts a CFNumber object to a python float or integer | def cf_number_to_number(value):
"""
Converts a CFNumber object to a python float or integer
:param value:
The CFNumber object
:return:
A python number (float or integer)
"""
type_ = CoreFoundation.CFNumberGetType(value)
type_name_ = {
... |
Creates a python unicode string from a CFString object | def cf_string_to_unicode(value):
"""
Creates a python unicode string from a CFString object
:param value:
The CFString to convert
:return:
A python unicode string
"""
string_ptr = CoreFoundation.CFStringGetCStringPtr(
value,
... |
Extracts a bytestring from a CFData object | def cf_data_to_bytes(value):
"""
Extracts a bytestring from a CFData object
:param value:
A CFData object
:return:
A byte string
"""
start = CoreFoundation.CFDataGetBytePtr(value)
num_bytes = CoreFoundation.CFDataGetLength(value)
... |
Creates a CFDictionaryRef object from a list of 2 - element tuples representing the key and value. Each key should be a CFStringRef and each value some sort of CF * type. | def cf_dictionary_from_pairs(pairs):
"""
Creates a CFDictionaryRef object from a list of 2-element tuples
representing the key and value. Each key should be a CFStringRef and each
value some sort of CF* type.
:param pairs:
A list of 2-element tuples
:return:... |
Creates a CFArrayRef object from a list of CF * type objects. | def cf_array_from_list(values):
"""
Creates a CFArrayRef object from a list of CF* type objects.
:param values:
A list of CF* type object
:return:
A CFArrayRef
"""
length = len(values)
return CoreFoundation.CFArrayCreate(
Cor... |
Creates a CFNumber object from an integer | def cf_number_from_integer(integer):
"""
Creates a CFNumber object from an integer
:param integer:
The integer to create the CFNumber for
:return:
A CFNumber
"""
integer_as_long = ffi.new('long *', integer)
return CoreFoundation.CFNumber... |
Serializes an asn1crypto. algos. DHParameters object into a byte string | def dump_dh_parameters(dh_parameters, encoding='pem'):
"""
Serializes an asn1crypto.algos.DHParameters object into a byte string
:param dh_parameters:
An asn1crypto.algos.DHParameters object
:param encoding:
A unicode string of "pem" or "der"
:return:
A byte string of the ... |
Serializes a public key object into a byte string | def dump_public_key(public_key, encoding='pem'):
"""
Serializes a public key object into a byte string
:param public_key:
An oscrypto.asymmetric.PublicKey or asn1crypto.keys.PublicKeyInfo object
:param encoding:
A unicode string of "pem" or "der"
:return:
A byte string of ... |
Serializes a certificate object into a byte string | def dump_certificate(certificate, encoding='pem'):
"""
Serializes a certificate object into a byte string
:param certificate:
An oscrypto.asymmetric.Certificate or asn1crypto.x509.Certificate object
:param encoding:
A unicode string of "pem" or "der"
:return:
A byte string... |
Serializes a private key object into a byte string of the PKCS#8 format | def dump_private_key(private_key, passphrase, encoding='pem', target_ms=200):
"""
Serializes a private key object into a byte string of the PKCS#8 format
:param private_key:
An oscrypto.asymmetric.PrivateKey or asn1crypto.keys.PrivateKeyInfo
object
:param passphrase:
A unicode ... |
Serializes a private key object into a byte string of the PEM formats used by OpenSSL. The format chosen will depend on the type of private key - RSA DSA or EC. | def dump_openssl_private_key(private_key, passphrase):
"""
Serializes a private key object into a byte string of the PEM formats used
by OpenSSL. The format chosen will depend on the type of private key - RSA,
DSA or EC.
Do not use this method unless you really must interact with a system that
... |
Checks a Security OSStatus error code and throws an exception if there is an error to report | def handle_sec_error(error, exception_class=None):
"""
Checks a Security OSStatus error code and throws an exception if there is an
error to report
:param error:
An OSStatus
:param exception_class:
The exception class to use for the exception if an error occurred
:raises:
... |
Extracts the function signature and description of a Python function | def _get_func_info(docstring, def_lineno, code_lines, prefix):
"""
Extracts the function signature and description of a Python function
:param docstring:
A unicode string of the docstring for the function
:param def_lineno:
An integer line number that function was defined on
:para... |
Walks through a CommonMark AST to find section headers that delineate content that should be updated by this script | def _find_sections(md_ast, sections, last, last_class, total_lines=None):
"""
Walks through a CommonMark AST to find section headers that delineate
content that should be updated by this script
:param md_ast:
The AST of the markdown document
:param sections:
A dict to store the sta... |
A callback used to walk the Python AST looking for classes functions methods and attributes. Generates chunks of markdown markup to replace the existing content. | def walk_ast(node, code_lines, sections, md_chunks):
"""
A callback used to walk the Python AST looking for classes, functions,
methods and attributes. Generates chunks of markdown markup to replace
the existing content.
:param node:
An _ast module node object
:param code_lines:
... |
Looks through the docs/ dir and parses each markdown document looking for sections to update from Python docstrings. Looks for section headers in the format: | def run():
"""
Looks through the docs/ dir and parses each markdown document, looking for
sections to update from Python docstrings. Looks for section headers in
the format:
- ### `ClassName()` class
- ##### `.method_name()` method
- ##### `.attribute_name` attribute
- ### `function... |
Generates a EC public/ private key pair | def ec_generate_pair(curve):
"""
Generates a EC public/private key pair
:param curve:
A unicode string. Valid values include "secp256r1", "secp384r1" and
"secp521r1".
:raises:
ValueError - when any of the parameters contain an invalid value
TypeError - when any of the p... |
Generates an ECDSA signature in pure Python ( thus slow ) | def ecdsa_sign(private_key, data, hash_algorithm):
"""
Generates an ECDSA signature in pure Python (thus slow)
:param private_key:
The PrivateKey to generate the signature with
:param data:
A byte string of the data the signature is for
:param hash_algorithm:
A unicode str... |
Verifies an ECDSA signature in pure Python ( thus slow ) | def ecdsa_verify(certificate_or_public_key, signature, data, hash_algorithm):
"""
Verifies an ECDSA signature in pure Python (thus slow)
:param certificate_or_public_key:
A Certificate or PublicKey instance to verify the signature with
:param signature:
A byte string of the signature t... |
Tries to find a CA certs bundle in common locations | def system_path():
"""
Tries to find a CA certs bundle in common locations
:raises:
OSError - when no valid CA certs bundle was found on the filesystem
:return:
The full filesystem path to a CA certs bundle file
"""
ca_path = None
# Common CA cert paths
paths = [
... |
Extracts trusted CA certs from the system CA cert bundle | def extract_from_system(cert_callback=None, callback_only_on_failure=False):
"""
Extracts trusted CA certs from the system CA cert bundle
:param cert_callback:
A callback that is called once for each certificate in the trust store.
It should accept two parameters: an asn1crypto.x509.Certifi... |
Extracts trusted CA certificates from the Windows certificate store | def extract_from_system(cert_callback=None, callback_only_on_failure=False):
"""
Extracts trusted CA certificates from the Windows certificate store
:param cert_callback:
A callback that is called once for each certificate in the trust store.
It should accept two parameters: an asn1crypto.x... |
Windows returns times as 64 - bit unsigned longs that are the number of hundreds of nanoseconds since Jan 1 1601. This converts it to a datetime object. | def _convert_filetime_to_timestamp(filetime):
"""
Windows returns times as 64-bit unsigned longs that are the number
of hundreds of nanoseconds since Jan 1 1601. This converts it to
a datetime object.
:param filetime:
A FILETIME struct object
:return:
An integer unix timestamp
... |
Extracts the X. 509 certificates from the server handshake bytes for use when debugging | def extract_chain(server_handshake_bytes):
"""
Extracts the X.509 certificates from the server handshake bytes for use
when debugging
:param server_handshake_bytes:
A byte string of the handshake data received from the server
:return:
A list of asn1crypto.x509.Certificate objects
... |
Determines if a CertificateRequest message is sent from the server asking the client for a certificate | def detect_client_auth_request(server_handshake_bytes):
"""
Determines if a CertificateRequest message is sent from the server asking
the client for a certificate
:param server_handshake_bytes:
A byte string of the handshake data received from the server
:return:
A boolean - if a c... |
Determines the length of the DH params from the ServerKeyExchange | def get_dh_params_length(server_handshake_bytes):
"""
Determines the length of the DH params from the ServerKeyExchange
:param server_handshake_bytes:
A byte string of the handshake data received from the server
:return:
None or an integer of the bit size of the DH parameters
"""
... |
Parses the handshake for protocol alerts | def parse_alert(server_handshake_bytes):
"""
Parses the handshake for protocol alerts
:param server_handshake_bytes:
A byte string of the handshake data received from the server
:return:
None or an 2-element tuple of integers:
0: 1 (warning) or 2 (fatal)
1: The alert ... |
Parse the TLS handshake from the client to the server to extract information including the cipher suite selected if compression is enabled the session id and if a new or reused session ticket exists. | def parse_session_info(server_handshake_bytes, client_handshake_bytes):
"""
Parse the TLS handshake from the client to the server to extract information
including the cipher suite selected, if compression is enabled, the
session id and if a new or reused session ticket exists.
:param server_handsha... |
Creates a generator returning tuples of information about each record in a byte string of data from a TLS client or server. Stops as soon as it find a ChangeCipherSpec message since all data from then on is encrypted. | def parse_tls_records(data):
"""
Creates a generator returning tuples of information about each record
in a byte string of data from a TLS client or server. Stops as soon as it
find a ChangeCipherSpec message since all data from then on is encrypted.
:param data:
A byte string of TLS record... |
Creates a generator returning tuples of information about each message in a byte string of data from a TLS handshake record | def parse_handshake_messages(data):
"""
Creates a generator returning tuples of information about each message in
a byte string of data from a TLS handshake record
:param data:
A byte string of a TLS handshake record data
:return:
A generator that yields 2-element tuples:
[... |
Creates a generator returning tuples of information about each extension from a byte string of extension data contained in a ServerHello ores ClientHello message | def _parse_hello_extensions(data):
"""
Creates a generator returning tuples of information about each extension
from a byte string of extension data contained in a ServerHello ores
ClientHello message
:param data:
A byte string of a extension data from a TLS ServerHello or ClientHello
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.