PHPXRef 0.7.1 : WordPress : Detail view of Compat.php

Class: ParagonIE_Sodium_Compat - X-Ref

Add two numbers (little-endian unsigned), storing the value in the first
parameter.

This mutates $val.

return: void
param: string $val
param: string $addv

base642bin($encoded, $variant, $ignore = '') X-Ref

return: string
param: string $encoded
param: int $variant
param: string $ignore

bin2base64($decoded, $variant) X-Ref

return: string
param: string $decoded
param: int $variant

bin2hex($string) X-Ref

Cache-timing-safe implementation of bin2hex().

return: string A hexadecimal-encoded string
param: string $string A string (probably raw binary)

compare($left, $right) X-Ref

Compare two strings, in constant-time.
Compared to memcmp(), compare() is more useful for sorting.

return: int If < 0 if the left operand is less than the right
param: string $left The left operand; must be a string
param: string $right The right operand; must be a string

crypto_aead_aes256gcm_is_available() X-Ref

Is AES-256-GCM even available to use?

return: bool

crypto_aead_aes256gcm_decrypt($ciphertext = '',$assocData = '',$nonce = '',$key = '') X-Ref

Authenticated Encryption with Associated Data: Decryption

Algorithm:
AES-256-GCM

This mode uses a 64-bit random nonce with a 64-bit counter.
IETF mode uses a 96-bit random nonce with a 32-bit counter.

return: string|bool       The original plaintext message
param: string $ciphertext Encrypted message (with Poly1305 MAC appended)
param: string $assocData  Authenticated Associated Data (unencrypted)
param: string $nonce      Number to be used only Once; must be 8 bytes
param: string $key        Encryption key

crypto_aead_aes256gcm_encrypt($plaintext = '',$assocData = '',$nonce = '',$key = '') X-Ref

Authenticated Encryption with Associated Data: Encryption

Algorithm:
AES-256-GCM

return: string           Ciphertext with a 16-byte GCM message
param: string $plaintext Message to be encrypted
param: string $assocData Authenticated Associated Data (unencrypted)
param: string $nonce     Number to be used only Once; must be 8 bytes
param: string $key       Encryption key

crypto_aead_aes256gcm_keygen() X-Ref

Return a secure random key for use with the AES-256-GCM
symmetric AEAD interface.

return: string

crypto_aead_chacha20poly1305_decrypt($ciphertext = '',$assocData = '',$nonce = '',$key = '') X-Ref

Authenticated Encryption with Associated Data: Decryption

Algorithm:
ChaCha20-Poly1305

This mode uses a 64-bit random nonce with a 64-bit counter.
IETF mode uses a 96-bit random nonce with a 32-bit counter.

return: string            The original plaintext message
param: string $ciphertext Encrypted message (with Poly1305 MAC appended)
param: string $assocData  Authenticated Associated Data (unencrypted)
param: string $nonce      Number to be used only Once; must be 8 bytes
param: string $key        Encryption key

crypto_aead_chacha20poly1305_encrypt($plaintext = '',$assocData = '',$nonce = '',$key = '') X-Ref

Authenticated Encryption with Associated Data

Algorithm:
ChaCha20-Poly1305

This mode uses a 64-bit random nonce with a 64-bit counter.
IETF mode uses a 96-bit random nonce with a 32-bit counter.

return: string           Ciphertext with a 16-byte Poly1305 message
param: string $plaintext Message to be encrypted
param: string $assocData Authenticated Associated Data (unencrypted)
param: string $nonce     Number to be used only Once; must be 8 bytes
param: string $key       Encryption key

crypto_aead_chacha20poly1305_ietf_decrypt($ciphertext = '',$assocData = '',$nonce = '',$key = '') X-Ref

Authenticated Encryption with Associated Data: Decryption

Algorithm:
ChaCha20-Poly1305

IETF mode uses a 96-bit random nonce with a 32-bit counter.
Regular mode uses a 64-bit random nonce with a 64-bit counter.

return: string            The original plaintext message
param: string $ciphertext Encrypted message (with Poly1305 MAC appended)
param: string $assocData  Authenticated Associated Data (unencrypted)
param: string $nonce      Number to be used only Once; must be 12 bytes
param: string $key        Encryption key

crypto_aead_chacha20poly1305_keygen() X-Ref

Return a secure random key for use with the ChaCha20-Poly1305
symmetric AEAD interface.

return: string

crypto_aead_chacha20poly1305_ietf_encrypt($plaintext = '',$assocData = '',$nonce = '',$key = '') X-Ref

Authenticated Encryption with Associated Data

Algorithm:
ChaCha20-Poly1305

IETF mode uses a 96-bit random nonce with a 32-bit counter.
Regular mode uses a 64-bit random nonce with a 64-bit counter.

return: string Ciphertext with a 16-byte Poly1305 message
param: string $plaintext Message to be encrypted
param: string $assocData Authenticated Associated Data (unencrypted)
param: string $nonce Number to be used only Once; must be 8 bytes
param: string $key Encryption key

crypto_aead_chacha20poly1305_ietf_keygen() X-Ref

Return a secure random key for use with the ChaCha20-Poly1305
symmetric AEAD interface. (IETF version)

return: string

crypto_aead_xchacha20poly1305_ietf_decrypt($ciphertext = '',$assocData = '',$nonce = '',$key = '',$dontFallback = false) X-Ref

Authenticated Encryption with Associated Data: Decryption

Algorithm:
XChaCha20-Poly1305

This mode uses a 64-bit random nonce with a 64-bit counter.
IETF mode uses a 96-bit random nonce with a 32-bit counter.

return: string|bool         The original plaintext message
param: string $ciphertext   Encrypted message (with Poly1305 MAC appended)
param: string $assocData    Authenticated Associated Data (unencrypted)
param: string $nonce        Number to be used only Once; must be 8 bytes
param: string $key          Encryption key
param: bool   $dontFallback Don't fallback to ext/sodium

crypto_aead_xchacha20poly1305_ietf_encrypt($plaintext = '',$assocData = '',$nonce = '',$key = '',$dontFallback = false) X-Ref

Authenticated Encryption with Associated Data

Algorithm:
XChaCha20-Poly1305

This mode uses a 64-bit random nonce with a 64-bit counter.
IETF mode uses a 96-bit random nonce with a 32-bit counter.

return: string           Ciphertext with a 16-byte Poly1305 message
param: string $plaintext    Message to be encrypted
param: string $assocData    Authenticated Associated Data (unencrypted)
param: string $nonce        Number to be used only Once; must be 8 bytes
param: string $key          Encryption key
param: bool   $dontFallback Don't fallback to ext/sodium

crypto_aead_xchacha20poly1305_ietf_keygen() X-Ref

Return a secure random key for use with the XChaCha20-Poly1305
symmetric AEAD interface.

return: string

crypto_auth($message, $key) X-Ref

Authenticate a message. Uses symmetric-key cryptography.

Algorithm:
HMAC-SHA512-256. Which is HMAC-SHA-512 truncated to 256 bits.
Not to be confused with HMAC-SHA-512/256 which would use the
SHA-512/256 hash function (uses different initial parameters
but still truncates to 256 bits to sidestep length-extension
attacks).

return: string Message authentication code
param: string $message Message to be authenticated
param: string $key Symmetric authentication key

crypto_auth_keygen() X-Ref

return: string

crypto_auth_verify($mac, $message, $key) X-Ref

Verify the MAC of a message previously authenticated with crypto_auth.

return: bool TRUE if authenticated, FALSE otherwise
param: string $mac Message authentication code
param: string $message Message whose authenticity you are attempting to
param: string $key Symmetric authentication key

crypto_box($plaintext, $nonce, $keypair) X-Ref

Authenticated asymmetric-key encryption. Both the sender and recipient
may decrypt messages.

Algorithm: X25519-XSalsa20-Poly1305.
X25519: Elliptic-Curve Diffie Hellman over Curve25519.
XSalsa20: Extended-nonce variant of salsa20.
Poyl1305: Polynomial MAC for one-time message authentication.

return: string Ciphertext with 16-byte Poly1305 MAC
param: string $plaintext The message to be encrypted
param: string $nonce A Number to only be used Once; must be 24 bytes
param: string $keypair Your secret key and your recipient's public key

crypto_box_seal($plaintext, $publicKey) X-Ref

Anonymous public-key encryption. Only the recipient may decrypt messages.

Algorithm: X25519-XSalsa20-Poly1305, as with crypto_box.
The sender's X25519 keypair is ephemeral.
Nonce is generated from the BLAKE2b hash of both public keys.

This provides ciphertext integrity.

return: string Sealed message that only your recipient can
param: string $plaintext Message to be sealed
param: string $publicKey Your recipient's public key

crypto_box_seal_open($ciphertext, $keypair) X-Ref

Opens a message encrypted with crypto_box_seal(). Requires
the recipient's keypair (sk || pk) to decrypt successfully.

This validates ciphertext integrity.

return: string The original plaintext message
param: string $ciphertext Sealed message to be opened
param: string $keypair Your crypto_box keypair

crypto_box_keypair() X-Ref

Generate a new random X25519 keypair.

return: string A 64-byte string; the first 32 are your secret key, while

crypto_box_keypair_from_secretkey_and_publickey($secretKey, $publicKey) X-Ref

Combine two keys into a keypair for use in library methods that expect
a keypair. This doesn't necessarily have to be the same person's keys.

return: string Keypair
param: string $secretKey Secret key
param: string $publicKey Public key

crypto_box_open($ciphertext, $nonce, $keypair) X-Ref

Decrypt a message previously encrypted with crypto_box().

return: string            The original plaintext message
param: string $ciphertext Encrypted message
param: string $nonce      Number to only be used Once; must be 24 bytes
param: string $keypair    Your secret key and the sender's public key

crypto_box_publickey($keypair) X-Ref

Extract the public key from a crypto_box keypair.

return: string Your crypto_box public key
param: string $keypair Keypair containing secret and public key

crypto_box_publickey_from_secretkey($secretKey) X-Ref

Calculate the X25519 public key from a given X25519 secret key.

return: string The corresponding X25519 public key
param: string $secretKey Any X25519 secret key

crypto_box_secretkey($keypair) X-Ref

Extract the secret key from a crypto_box keypair.

return: string Your crypto_box secret key
param: string $keypair

crypto_box_seed_keypair($seed) X-Ref

Generate an X25519 keypair from a seed.

return: string
param: string $seed

crypto_generichash($message, $key = '', $length = self::CRYPTO_GENERICHASH_BYTES) X-Ref

Calculates a BLAKE2b hash, with an optional key.

return: string              Raw binary
param: string      $message The message to be hashed
param: string|null $key     If specified, must be a string between 16
param: int         $length  Output length in bytes; must be between 16

crypto_generichash_final(&$ctx, $length = self::CRYPTO_GENERICHASH_BYTES) X-Ref

Get the final BLAKE2b hash output for a given context.

return: string Final BLAKE2b hash.
param: string $ctx BLAKE2 hashing context. Generated by crypto_generichash_init().
param: int $length Hash output size.

crypto_generichash_init($key = '', $length = self::CRYPTO_GENERICHASH_BYTES) X-Ref

crypto_generichash_init_salt_personal($key = '',$length = self::CRYPTO_GENERICHASH_BYTES,$salt = '',$personal = '') X-Ref

Initialize a BLAKE2b hashing context, for use in a streaming interface.

return: string          A BLAKE2 hashing context, encoded as a string
param: string|null $key If specified must be a string between 16 and 64 bytes
param: int $length      The size of the desired hash output
param: string $salt     Salt (up to 16 bytes)
param: string $personal Personalization string (up to 16 bytes)

crypto_generichash_update(&$ctx, $message) X-Ref

Update a BLAKE2b hashing context with additional data.

return: void
param: string $ctx BLAKE2 hashing context. Generated by crypto_generichash_init().
param: -out string $ctx
param: string $message The message to append to the existing hash state.

crypto_generichash_keygen() X-Ref

return: string

crypto_kdf_derive_from_key($subkey_len,$subkey_id,$context,$key) X-Ref

return: string
param: int $subkey_len
param: int $subkey_id
param: string $context
param: string $key

crypto_kdf_keygen() X-Ref

return: string

crypto_kx($my_secret, $their_public, $client_public, $server_public, $dontFallback = false) X-Ref

Perform a key exchange, between a designated client and a server.

Typically, you would designate one machine to be the client and the
other to be the server. The first two keys are what you'd expect for
scalarmult() below, but the latter two public keys don't swap places.

| ALICE                          | BOB                                 |
| Client                         | Server                              |
|--------------------------------|-------------------------------------|
| shared = crypto_kx(            | shared = crypto_kx(                 |
|     alice_sk,                  |     bob_sk,                         | <- contextual
|     bob_pk,                    |     alice_pk,                       | <- contextual
|     alice_pk,                  |     alice_pk,                       | <----- static
|     bob_pk                     |     bob_pk                          | <----- static
| )                              | )                                   |

They are used along with the scalarmult product to generate a 256-bit
BLAKE2b hash unique to the client and server keys.

return: string
param: string $my_secret
param: string $their_public
param: string $client_public
param: string $server_public
param: bool $dontFallback

crypto_kx_seed_keypair($seed) X-Ref

return: string
param: string $seed

crypto_kx_keypair() X-Ref

return: string

crypto_kx_client_session_keys($keypair, $serverPublicKey) X-Ref

return: array{0: string, 1: string}
param: string $keypair
param: string $serverPublicKey

crypto_kx_server_session_keys($keypair, $clientPublicKey) X-Ref

return: array{0: string, 1: string}
param: string $keypair
param: string $clientPublicKey

crypto_kx_secretkey($kp) X-Ref

return: string
param: string $kp

crypto_kx_publickey($kp) X-Ref

return: string
param: string $kp

crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $alg = null) X-Ref

return: string
param: int $outlen
param: string $passwd
param: string $salt
param: int $opslimit
param: int $memlimit
param: int|null $alg

crypto_pwhash_is_available() X-Ref

!Exclusive to sodium_compat!

This returns TRUE if the native crypto_pwhash API is available by libsodium.
This returns FALSE if only sodium_compat is available.

return: bool

crypto_pwhash_str($passwd, $opslimit, $memlimit) X-Ref

return: string
param: string $passwd
param: int $opslimit
param: int $memlimit

crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit) X-Ref

Do we need to rehash this password?

return: bool
param: string $hash
param: int $opslimit
param: int $memlimit

crypto_pwhash_str_verify($passwd, $hash) X-Ref

return: bool
param: string $passwd
param: string $hash

crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit) X-Ref

return: string
param: int $outlen
param: string $passwd
param: string $salt
param: int $opslimit
param: int $memlimit

crypto_pwhash_scryptsalsa208sha256_is_available() X-Ref

!Exclusive to sodium_compat!

This returns TRUE if the native crypto_pwhash API is available by libsodium.
This returns FALSE if only sodium_compat is available.

return: bool

crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit) X-Ref

return: string
param: string $passwd
param: int $opslimit
param: int $memlimit

crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash) X-Ref

return: bool
param: string $passwd
param: string $hash

crypto_scalarmult($secretKey, $publicKey) X-Ref

Calculate the shared secret between your secret key and your
recipient's public key.

Algorithm: X25519 (ECDH over Curve25519)

return: string
param: string $secretKey
param: string $publicKey

crypto_scalarmult_base($secretKey) X-Ref

Calculate an X25519 public key from an X25519 secret key.

return: string
param: string $secretKey

crypto_secretbox($plaintext, $nonce, $key) X-Ref

Authenticated symmetric-key encryption.

Algorithm: XSalsa20-Poly1305

return: string Ciphertext with Poly1305 MAC
param: string $plaintext The message you're encrypting
param: string $nonce A Number to be used Once; must be 24 bytes
param: string $key Symmetric encryption key

crypto_secretbox_open($ciphertext, $nonce, $key) X-Ref

Decrypts a message previously encrypted with crypto_secretbox().

return: string            Original plaintext message
param: string $ciphertext Ciphertext with Poly1305 MAC
param: string $nonce      A Number to be used Once; must be 24 bytes
param: string $key        Symmetric encryption key

crypto_secretbox_keygen() X-Ref

Return a secure random key for use with crypto_secretbox

return: string

crypto_secretbox_xchacha20poly1305($plaintext, $nonce, $key) X-Ref

Authenticated symmetric-key encryption.

Algorithm: XChaCha20-Poly1305

return: string           Ciphertext with Poly1305 MAC
param: string $plaintext The message you're encrypting
param: string $nonce     A Number to be used Once; must be 24 bytes
param: string $key       Symmetric encryption key

crypto_secretbox_xchacha20poly1305_open($ciphertext, $nonce, $key) X-Ref

Decrypts a message previously encrypted with crypto_secretbox_xchacha20poly1305().

return: string            Original plaintext message
param: string $ciphertext Ciphertext with Poly1305 MAC
param: string $nonce      A Number to be used Once; must be 24 bytes
param: string $key        Symmetric encryption key

crypto_secretstream_xchacha20poly1305_init_push($key) X-Ref

return: array<int, string> Returns a state and a header.
param: string $key

crypto_secretstream_xchacha20poly1305_init_pull($header, $key) X-Ref

return: string Returns a state.
param: string $header
param: string $key

crypto_secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0) X-Ref

return: string
param: string $state
param: string $msg
param: string $aad
param: int $tag

crypto_secretstream_xchacha20poly1305_pull(&$state, $msg, $aad = '') X-Ref

return: bool|array{0: string, 1: int}
param: string $state
param: string $msg
param: string $aad

crypto_secretstream_xchacha20poly1305_keygen() X-Ref

return: string

crypto_secretstream_xchacha20poly1305_rekey(&$state) X-Ref

return: void
param: string $state

crypto_shorthash($message, $key) X-Ref

Calculates a SipHash-2-4 hash of a message for a given key.

return: string Hash
param: string $message Input message
param: string $key SipHash-2-4 key

crypto_shorthash_keygen() X-Ref

Return a secure random key for use with crypto_shorthash

return: string

crypto_sign($message, $secretKey) X-Ref

Returns a signed message. You probably want crypto_sign_detached()
instead, which only returns the signature.

Algorithm: Ed25519 (EdDSA over Curve25519)

return: string Signed message (signature is prefixed).
param: string $message Message to be signed.
param: string $secretKey Secret signing key.

crypto_sign_open($signedMessage, $publicKey) X-Ref

Validates a signed message then returns the message.

return: string The original message (if the signature is
param: string $signedMessage A signed message
param: string $publicKey A public key

crypto_sign_keypair() X-Ref

Generate a new random Ed25519 keypair.

return: string

crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk) X-Ref

return: string
param: string $sk
param: string $pk

crypto_sign_seed_keypair($seed) X-Ref

Generate an Ed25519 keypair from a seed.

return: string Keypair
param: string $seed Input seed

crypto_sign_publickey($keypair) X-Ref

Extract an Ed25519 public key from an Ed25519 keypair.

return: string Public key
param: string $keypair Keypair

crypto_sign_publickey_from_secretkey($secretKey) X-Ref

Calculate an Ed25519 public key from an Ed25519 secret key.

return: string The corresponding Ed25519 public key
param: string $secretKey Your Ed25519 secret key

crypto_sign_secretkey($keypair) X-Ref

Extract an Ed25519 secret key from an Ed25519 keypair.

return: string Secret key
param: string $keypair Keypair

crypto_sign_detached($message, $secretKey) X-Ref

Calculate the Ed25519 signature of a message and return ONLY the signature.

Algorithm: Ed25519 (EdDSA over Curve25519)

return: string Digital signature
param: string $message Message to be signed
param: string $secretKey Secret signing key

crypto_sign_verify_detached($signature, $message, $publicKey) X-Ref

Verify the Ed25519 signature of a message.

return: bool TRUE if this signature is good for this public key;
param: string $signature Digital sginature
param: string $message Message to be verified
param: string $publicKey Public key

crypto_sign_ed25519_pk_to_curve25519($pk) X-Ref

Convert an Ed25519 public key to a Curve25519 public key

return: string
param: string $pk

crypto_sign_ed25519_sk_to_curve25519($sk) X-Ref

Convert an Ed25519 secret key to a Curve25519 secret key

return: string
param: string $sk

crypto_stream($len, $nonce, $key) X-Ref

Expand a key and nonce into a keystream of pseudorandom bytes.

return: string Pseudorandom stream that can be XORed with messages
param: int $len Number of bytes desired
param: string $nonce Number to be used Once; must be 24 bytes
param: string $key XSalsa20 key

crypto_stream_xor($message, $nonce, $key) X-Ref

DANGER! UNAUTHENTICATED ENCRYPTION!

Unless you are following expert advice, do not use this feature.

Algorithm: XSalsa20

This DOES NOT provide ciphertext integrity.

return: string Encrypted text which is vulnerable to chosen-
param: string $message Plaintext message
param: string $nonce Number to be used Once; must be 24 bytes
param: string $key Encryption key

crypto_stream_keygen() X-Ref

Return a secure random key for use with crypto_stream

return: string

crypto_stream_xchacha20($len, $nonce, $key, $dontFallback = false) X-Ref

crypto_stream_xchacha20_xor($message, $nonce, $key, $dontFallback = false) X-Ref

DANGER! UNAUTHENTICATED ENCRYPTION!

Unless you are following expert advice, do not use this feature.

Algorithm: XChaCha20

This DOES NOT provide ciphertext integrity.

return: string Encrypted text which is vulnerable to chosen-
param: string $message Plaintext message
param: string $nonce Number to be used Once; must be 24 bytes
param: string $key Encryption key
param: bool $dontFallback

crypto_stream_xchacha20_keygen() X-Ref

Return a secure random key for use with crypto_stream_xchacha20

return: string

hex2bin($string) X-Ref

Cache-timing-safe implementation of hex2bin().

return: string Raw binary string
param: string $string Hexadecimal string

increment(&$var) X-Ref

Increase a string (little endian)

return: void
param: string $var

is_zero($str) X-Ref

return: bool
param: string $str

library_version_major() X-Ref

The equivalent to the libsodium minor version we aim to be compatible
with (sans pwhash and memzero).

return: int

library_version_minor() X-Ref

The equivalent to the libsodium minor version we aim to be compatible
with (sans pwhash and memzero).

return: int

memcmp($left, $right) X-Ref

Compare two strings.

return: int
param: string $left
param: string $right

memzero(&$var) X-Ref

It's actually not possible to zero memory buffers in PHP. You need the
native library for that.

return: void
param: string|null $var
param: -out string|null $var

pad($unpadded, $blockSize, $dontFallback = false) X-Ref

return: string
param: string $unpadded
param: int $blockSize
param: bool $dontFallback

unpad($padded, $blockSize, $dontFallback = false) X-Ref

return: string
param: string $padded
param: int $blockSize
param: bool $dontFallback

polyfill_is_fast() X-Ref

Will sodium_compat run fast on the current hardware and PHP configuration?

return: bool

randombytes_buf($numBytes) X-Ref

Generate a string of bytes from the kernel's CSPRNG.
Proudly uses /dev/urandom (if getrandom(2) is not available).

return: string
param: int $numBytes

randombytes_uniform($range) X-Ref

Generate an integer between 0 and $range (non-inclusive).

return: int
param: int $range

randombytes_random16() X-Ref

Generate a random 16-bit integer.

return: int

ristretto255_is_valid_point($p, $dontFallback = false) X-Ref

return: bool
param: string $p
param: bool $dontFallback

ristretto255_add($p, $q, $dontFallback = false) X-Ref

return: string
param: string $p
param: string $q
param: bool $dontFallback

ristretto255_sub($p, $q, $dontFallback = false) X-Ref

return: string
param: string $p
param: string $q
param: bool $dontFallback

ristretto255_from_hash($r, $dontFallback = false) X-Ref

return: string
param: string $r
param: bool $dontFallback

ristretto255_random($dontFallback = false) X-Ref

return: string
param: bool $dontFallback

ristretto255_scalar_random($dontFallback = false) X-Ref

return: string
param: bool $dontFallback

ristretto255_scalar_invert($s, $dontFallback = false) X-Ref

return: string
param: string $s
param: bool $dontFallback

ristretto255_scalar_negate($s, $dontFallback = false) X-Ref

return: string
param: string $s
param: bool $dontFallback

ristretto255_scalar_complement($s, $dontFallback = false) X-Ref

return: string
param: string $s
param: bool $dontFallback

ristretto255_scalar_add($x, $y, $dontFallback = false) X-Ref

return: string
param: string $x
param: string $y
param: bool $dontFallback

ristretto255_scalar_sub($x, $y, $dontFallback = false) X-Ref

return: string
param: string $x
param: string $y
param: bool $dontFallback

ristretto255_scalar_mul($x, $y, $dontFallback = false) X-Ref

return: string
param: string $x
param: string $y
param: bool $dontFallback

scalarmult_ristretto255($n, $p, $dontFallback = false) X-Ref

return: string
param: string $n
param: string $p
param: bool $dontFallback

scalarmult_ristretto255_base($n, $dontFallback = false) X-Ref

return: string
param: string $n
param: string $p
param: bool $dontFallback

ristretto255_scalar_reduce($s, $dontFallback = false) X-Ref

return: string
param: string $s
param: bool $dontFallback

runtime_speed_test($iterations, $maxTimeout) X-Ref

Runtime testing method for 32-bit platforms.

Usage: If runtime_speed_test() returns FALSE, then our 32-bit
implementation is to slow to use safely without risking timeouts.
If this happens, install sodium from PECL to get acceptable
performance.

return: bool TRUE if we're fast enough, FALSE is not
param: int $iterations Number of multiplications to attempt
param: int $maxTimeout Milliseconds

sub(&$val, $addv) X-Ref

Add two numbers (little-endian unsigned), storing the value in the first
parameter.

This mutates $val.

return: void
param: string $val
param: string $addv

version_string() X-Ref

This emulates libsodium's version_string() function, except ours is
prefixed with 'polyfill-'.

return: string

use_fallback($sodium_func_name = '') X-Ref

Should we use the libsodium core function instead?
This is always a good idea, if it's available. (Unless we're in the
middle of running our unit test suite.)

If ext/libsodium is available, use it. Return TRUE.
Otherwise, we have to use the code provided herein. Return FALSE.

return: bool
param: string $sodium_func_name

useNewSodiumAPI() X-Ref

Libsodium as implemented in PHP 7.2
and/or ext/sodium (via PECL)

return: bool

File Size:	3951 lines (148 kb)
Included or required:	0 times
Referenced:	0 times
Includes or requires:	0 files

PHP Cross Reference of WordPress

/wp-includes/sodium_compat/src/ -> Compat.php (summary)

Defines 1 class