visaljs 0.0.1 → 0.0.3

package/runtime/third_party/boringssl/include/openssl/evp_errors.h

@@ -0,0 +1,66 @@
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPENSSL_HEADER_EVP_ERRORS_H
+#define OPENSSL_HEADER_EVP_ERRORS_H
+
+#define EVP_R_BUFFER_TOO_SMALL 100
+#define EVP_R_COMMAND_NOT_SUPPORTED 101
+#define EVP_R_DECODE_ERROR 102
+#define EVP_R_DIFFERENT_KEY_TYPES 103
+#define EVP_R_DIFFERENT_PARAMETERS 104
+#define EVP_R_ENCODE_ERROR 105
+#define EVP_R_EXPECTING_A_EC_KEY 106
+#define EVP_R_EXPECTING_AN_RSA_KEY 107
+#define EVP_R_EXPECTING_A_DSA_KEY 108
+#define EVP_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE 109
+#define EVP_R_INVALID_DIGEST_LENGTH 110
+#define EVP_R_INVALID_DIGEST_TYPE 111
+#define EVP_R_INVALID_KEYBITS 112
+#define EVP_R_INVALID_MGF1_MD 113
+#define EVP_R_INVALID_OPERATION 114
+#define EVP_R_INVALID_PADDING_MODE 115
+#define EVP_R_INVALID_PSS_SALTLEN 116
+#define EVP_R_KEYS_NOT_SET 117
+#define EVP_R_MISSING_PARAMETERS 118
+#define EVP_R_NO_DEFAULT_DIGEST 119
+#define EVP_R_NO_KEY_SET 120
+#define EVP_R_NO_MDC2_SUPPORT 121
+#define EVP_R_NO_NID_FOR_CURVE 122
+#define EVP_R_NO_OPERATION_SET 123
+#define EVP_R_NO_PARAMETERS_SET 124
+#define EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 125
+#define EVP_R_OPERATION_NOT_INITIALIZED 126
+#define EVP_R_UNKNOWN_PUBLIC_KEY_TYPE 127
+#define EVP_R_UNSUPPORTED_ALGORITHM 128
+#define EVP_R_UNSUPPORTED_PUBLIC_KEY_TYPE 129
+#define EVP_R_NOT_A_PRIVATE_KEY 130
+#define EVP_R_INVALID_SIGNATURE 131
+#define EVP_R_MEMORY_LIMIT_EXCEEDED 132
+#define EVP_R_INVALID_PARAMETERS 133
+#define EVP_R_INVALID_PEER_KEY 134
+#define EVP_R_NOT_XOF_OR_INVALID_LENGTH 135
+#define EVP_R_EMPTY_PSK 136
+#define EVP_R_INVALID_BUFFER_SIZE 137
+#define EVP_R_EXPECTING_A_DH_KEY 138
+#define EVP_R_PRIVATE_KEY_WAS_NOT_SEED 139
+#define EVP_R_MISSING_PUBLIC_KEY 140
+#define EVP_R_INVALID_CIPHERTEXT_LENGTH 141
+#define EVP_R_INVALID_SECRET_LENGTH 142
+#define EVP_R_INVALID_ENTROPY_LENGTH 143
+
+// Compatibility defines.
+#define EVP_R_OPERATON_NOT_INITIALIZED EVP_R_OPERATION_NOT_INITIALIZED
+
+#endif  // OPENSSL_HEADER_EVP_ERRORS_H

package/runtime/third_party/boringssl/include/openssl/ex_data.h

@@ -0,0 +1,117 @@
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPENSSL_HEADER_EX_DATA_H
+#define OPENSSL_HEADER_EX_DATA_H
+
+#include <openssl/base.h>  // IWYU pragma: export
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// ex_data is a mechanism for associating arbitrary extra data with objects.
+// For each type of object that supports ex_data, different users can be
+// assigned indexes in which to store their data. Each index has callback
+// functions that are called when an object of that type is freed or
+// duplicated.
+
+
+// Type-specific functions.
+
+#if 0  // Sample
+
+// Each type that supports ex_data provides three functions:
+
+// TYPE_get_ex_new_index allocates a new index for `TYPE`. An optional
+// `free_func` argument may be provided which is called when the owning object
+// is destroyed. See `CRYPTO_EX_free` for details. The `argl` and `argp`
+// arguments are opaque values that are passed to the callback. It returns the
+// new index or a negative number on error.
+OPENSSL_EXPORT int TYPE_get_ex_new_index(long argl, void *argp,
+                                         CRYPTO_EX_unused *unused,
+                                         CRYPTO_EX_dup *dup_unused,
+                                         CRYPTO_EX_free *free_func);
+
+// TYPE_set_ex_data sets an extra data pointer on `t`. The `index` argument
+// must have been returned from a previous call to `TYPE_get_ex_new_index`.
+OPENSSL_EXPORT int TYPE_set_ex_data(TYPE *t, int index, void *arg);
+
+// TYPE_get_ex_data returns an extra data pointer for `t`, or NULL if no such
+// pointer exists. The `index` argument should have been returned from a
+// previous call to `TYPE_get_ex_new_index`.
+OPENSSL_EXPORT void *TYPE_get_ex_data(const TYPE *t, int index);
+
+// Some types additionally preallocate index zero, with all callbacks set to
+// NULL. Applications that do not need the general ex_data machinery may use
+// this instead.
+
+// TYPE_set_app_data sets `t`'s application data pointer to `arg`. It returns
+// one on success and zero on error.
+OPENSSL_EXPORT int TYPE_set_app_data(TYPE *t, void *arg);
+
+// TYPE_get_app_data returns the application data pointer for `t`, or NULL if no
+// such pointer exists.
+OPENSSL_EXPORT void *TYPE_get_app_data(const TYPE *t);
+
+#endif  // Sample
+
+
+// Callback types.
+
+// CRYPTO_EX_DATA, in the public API, is an opaque struct that is never returned
+// from the library.
+typedef struct crypto_ex_data_st CRYPTO_EX_DATA;
+
+// CRYPTO_EX_free is a callback function that is called when an object of the
+// class with extra data pointers is being destroyed. For example, if this
+// callback has been passed to `SSL_get_ex_new_index` then it may be called each
+// time an `SSL*` is destroyed.
+//
+// `parent` and `ad` will be NULL. Historically, the parent object was passed in
+// `parent`, but accessing the pointer was not safe because `parent` was in the
+// process of being destroyed. If the callback has access to some other pointer
+// to the parent object, it must not pass the pointer to any BoringSSL APIs.
+// Mid-destruction, invariants on the parent object no longer hold.
+//
+// The arguments `argl` and `argp` contain opaque values that were given to
+// `CRYPTO_get_ex_new_index_ex`.
+//
+// This callback may be called with a NULL value for `ptr` if the object has no
+// value set for this index. However, the callbacks may also be skipped entirely
+// if no extra data pointers are set on the object at all.
+typedef void CRYPTO_EX_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
+                            int index, long argl, void *argp);
+
+
+// Deprecated functions.
+
+// CRYPTO_cleanup_all_ex_data does nothing.
+OPENSSL_EXPORT void CRYPTO_cleanup_all_ex_data(void);
+
+// CRYPTO_EX_dup is a legacy callback function type which is ignored.
+typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from,
+                          void **from_d, int index, long argl, void *argp);
+
+// CRYPTO_EX_unused is a placeholder for an unused callback. It is aliased to
+// int to ensure non-NULL callers fail to compile rather than fail silently.
+typedef int CRYPTO_EX_unused;
+
+
+#if defined(__cplusplus)
+}  // extern C
+#endif
+
+#endif  // OPENSSL_HEADER_EX_DATA_H

package/runtime/third_party/boringssl/include/openssl/hkdf.h

@@ -0,0 +1,68 @@
+// Copyright 2014 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPENSSL_HEADER_HKDF_H
+#define OPENSSL_HEADER_HKDF_H
+
+#include <openssl/base.h>   // IWYU pragma: export
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// HKDF.
+
+
+// HKDF computes HKDF (as specified by RFC 5869) of initial keying material
+// `secret` with `salt` and `info` using `digest`, and outputs `out_len` bytes
+// to `out_key`. It returns one on success and zero on error.
+//
+// HKDF is an Extract-and-Expand algorithm. It does not do any key stretching,
+// and as such, is not suited to be used alone to generate a key from a
+// password.
+OPENSSL_EXPORT int HKDF(uint8_t *out_key, size_t out_len, const EVP_MD *digest,
+                        const uint8_t *secret, size_t secret_len,
+                        const uint8_t *salt, size_t salt_len,
+                        const uint8_t *info, size_t info_len);
+
+// HKDF_extract computes a HKDF PRK (as specified by RFC 5869) from initial
+// keying material `secret` and salt `salt` using `digest`, and outputs
+// `out_len` bytes to `out_key`. The maximum output size is `EVP_MAX_MD_SIZE`.
+// It returns one on success and zero on error.
+//
+// WARNING: This function orders the inputs differently from RFC 5869
+// specification. Double-check which parameter is the secret/IKM and which is
+// the salt when using.
+OPENSSL_EXPORT int HKDF_extract(uint8_t *out_key, size_t *out_len,
+                                const EVP_MD *digest, const uint8_t *secret,
+                                size_t secret_len, const uint8_t *salt,
+                                size_t salt_len);
+
+// HKDF_expand computes a HKDF OKM (as specified by RFC 5869) of length
+// `out_len` from the PRK `prk` and info `info` using `digest`, and outputs
+// the result to `out_key`. It returns one on success and zero on error.
+OPENSSL_EXPORT int HKDF_expand(uint8_t *out_key, size_t out_len,
+                               const EVP_MD *digest, const uint8_t *prk,
+                               size_t prk_len, const uint8_t *info,
+                               size_t info_len);
+
+
+#if defined(__cplusplus)
+}  // extern C
+#endif
+
+#define HKDF_R_OUTPUT_TOO_LARGE 100
+
+#endif  // OPENSSL_HEADER_HKDF_H

package/runtime/third_party/boringssl/include/openssl/hmac.h

@@ -0,0 +1,151 @@
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OPENSSL_HEADER_HMAC_H
+#define OPENSSL_HEADER_HMAC_H
+
+#include <openssl/base.h>   // IWYU pragma: export
+
+#include <openssl/digest.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// HMAC contains functions for constructing PRFs from Merkle–Damgård hash
+// functions using HMAC.
+
+
+// One-shot operation.
+
+// HMAC calculates the HMAC of `data_len` bytes of `data`, using the given key
+// and hash function, and writes the result to `out`. On entry, `out` must
+// contain at least `EVP_MD_size` bytes of space. The actual length of the
+// result is written to `*out_len`. An output size of `EVP_MAX_MD_SIZE` will
+// always be large enough. It returns `out` or NULL on error.
+OPENSSL_EXPORT uint8_t *HMAC(const EVP_MD *evp_md, const void *key,
+                             size_t key_len, const uint8_t *data,
+                             size_t data_len, uint8_t *out,
+                             unsigned int *out_len);
+
+
+// Incremental operation.
+
+// HMAC_CTX_init initialises `ctx` for use in an HMAC operation. It's assumed
+// that HMAC_CTX objects will be allocated on the stack thus no allocation
+// function is provided.
+OPENSSL_EXPORT void HMAC_CTX_init(HMAC_CTX *ctx);
+
+// HMAC_CTX_new allocates and initialises a new `HMAC_CTX` and returns it, or
+// NULL on allocation failure. The caller must use `HMAC_CTX_free` to release
+// the resulting object.
+OPENSSL_EXPORT HMAC_CTX *HMAC_CTX_new(void);
+
+// HMAC_CTX_cleanup frees data owned by `ctx`. It does not free `ctx` itself.
+OPENSSL_EXPORT void HMAC_CTX_cleanup(HMAC_CTX *ctx);
+
+// HMAC_CTX_cleanse zeros the digest state from `ctx` and then performs the
+// actions of `HMAC_CTX_cleanup`.
+OPENSSL_EXPORT void HMAC_CTX_cleanse(HMAC_CTX *ctx);
+
+// HMAC_CTX_free calls `HMAC_CTX_cleanup` and then frees `ctx` itself.
+OPENSSL_EXPORT void HMAC_CTX_free(HMAC_CTX *ctx);
+
+// HMAC_Init_ex sets up an initialised `HMAC_CTX` to use `md` as the hash
+// function and `key` as the key. For a non-initial call, `md` may be NULL, in
+// which case the previous hash function will be used. If the hash function has
+// not changed and `key` is NULL, `ctx` reuses the previous key. It returns one
+// on success or zero on allocation failure.
+//
+// WARNING: NULL and empty keys are ambiguous on non-initial calls. Passing NULL
+// `key` but repeating the previous `md` reuses the previous key rather than the
+// empty key.
+OPENSSL_EXPORT int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, size_t key_len,
+                                const EVP_MD *md, ENGINE *impl);
+
+// HMAC_Update hashes `data_len` bytes from `data` into the current HMAC
+// operation in `ctx`. It returns one.
+OPENSSL_EXPORT int HMAC_Update(HMAC_CTX *ctx, const uint8_t *data,
+                               size_t data_len);
+
+// HMAC_Final completes the HMAC operation in `ctx` and writes the result to
+// `out`. If `out_len` is not `NULL` then it writes the length of the result to
+// `*out_len`. On entry, `out` must contain at least `HMAC_size` bytes of
+// space. An output size of `EVP_MAX_MD_SIZE` will always be large enough. It
+// returns one on success or zero on allocation failure.
+OPENSSL_EXPORT int HMAC_Final(HMAC_CTX *ctx, uint8_t *out,
+                              unsigned int *out_len);
+
+
+// Utility functions.
+
+// HMAC_size returns the size, in bytes, of the HMAC that will be produced by
+// `ctx`. On entry, `ctx` must have been setup with `HMAC_Init_ex`.
+OPENSSL_EXPORT size_t HMAC_size(const HMAC_CTX *ctx);
+
+// HMAC_CTX_get_md returns `ctx`'s hash function.
+OPENSSL_EXPORT const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx);
+
+// HMAC_CTX_copy_ex sets `dest` equal to `src`. On entry, `dest` must have been
+// initialised by calling `HMAC_CTX_init`. It returns one on success and zero
+// on error.
+OPENSSL_EXPORT int HMAC_CTX_copy_ex(HMAC_CTX *dest, const HMAC_CTX *src);
+
+// HMAC_CTX_reset calls `HMAC_CTX_cleanup` followed by `HMAC_CTX_init`.
+OPENSSL_EXPORT void HMAC_CTX_reset(HMAC_CTX *ctx);
+
+
+// Deprecated functions.
+
+OPENSSL_EXPORT int HMAC_Init(HMAC_CTX *ctx, const void *key, int key_len,
+                             const EVP_MD *md);
+
+// HMAC_CTX_copy calls `HMAC_CTX_init` on `dest` and then sets it equal to
+// `src`. On entry, `dest` must /not/ be initialised for an operation with
+// `HMAC_Init_ex`. It returns one on success and zero on error.
+OPENSSL_EXPORT int HMAC_CTX_copy(HMAC_CTX *dest, const HMAC_CTX *src);
+
+
+// Private functions
+
+struct hmac_ctx_st {
+  const EVP_MD *md;
+  EVP_MD_CTX md_ctx;
+  EVP_MD_CTX i_ctx;
+  EVP_MD_CTX o_ctx;
+} /* HMAC_CTX */;
+
+
+#if defined(__cplusplus)
+}  // extern C
+
+#if !defined(BORINGSSL_NO_CXX)
+extern "C++" {
+
+BSSL_NAMESPACE_BEGIN
+
+BORINGSSL_MAKE_DELETER(HMAC_CTX, HMAC_CTX_free)
+
+BORINGSSL_MAKE_STACK_TRAITS(HMAC_CTX, HMAC_CTX_init, HMAC_CTX_cleanup)
+using ScopedHMAC_CTX = internal::StackAllocated<HMAC_CTX>;
+
+BSSL_NAMESPACE_END
+
+}  // extern C++
+#endif
+
+#endif
+
+#endif  // OPENSSL_HEADER_HMAC_H