godot/core/crypto/crypto.cpp

/**************************************************************************/
/*  crypto.cpp                                                            */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#include "crypto.h"

#include "core/config/engine.h"
#include "core/io/certs_compressed.gen.h"
#include "core/io/compression.h"

/// Resources

CryptoKey *(*CryptoKey::_create)(bool p_notify_postinitialize) = …;
CryptoKey *CryptoKey::create(bool p_notify_postinitialize) { … }

void CryptoKey::_bind_methods() { … }

X509Certificate *(*X509Certificate::_create)(bool p_notify_postinitialize) = …;
X509Certificate *X509Certificate::create(bool p_notify_postinitialize) { … }

void X509Certificate::_bind_methods() { … }

/// TLSOptions

Ref<TLSOptions> TLSOptions::client(Ref<X509Certificate> p_trusted_chain, const String &p_common_name_override) { … }

Ref<TLSOptions> TLSOptions::client_unsafe(Ref<X509Certificate> p_trusted_chain) { … }

Ref<TLSOptions> TLSOptions::server(Ref<CryptoKey> p_own_key, Ref<X509Certificate> p_own_certificate) { … }

void TLSOptions::_bind_methods() { … }

/// HMACContext

void HMACContext::_bind_methods() { … }

HMACContext *(*HMACContext::_create)(bool p_notify_postinitialize) = …;
HMACContext *HMACContext::create(bool p_notify_postinitialize) { … }

/// Crypto

void (*Crypto::_load_default_certificates)(const String &p_path) = …;
Crypto *(*Crypto::_create)(bool p_notify_postinitialize) = …;
Crypto *Crypto::create(bool p_notify_postinitialize) { … }

void Crypto::load_default_certificates(const String &p_path) { … }

PackedByteArray Crypto::hmac_digest(HashingContext::HashType p_hash_type, const PackedByteArray &p_key, const PackedByteArray &p_msg) { … }

// Compares two HMACS for equality without leaking timing information in order to prevent timing attacks.
// @see: https://paragonie.com/blog/2015/11/preventing-timing-attacks-on-string-comparison-with-double-hmac-strategy
bool Crypto::constant_time_compare(const PackedByteArray &p_trusted, const PackedByteArray &p_received) { … }

void Crypto::_bind_methods() { … }

/// Resource loader/saver

Ref<Resource> ResourceFormatLoaderCrypto::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) { … }

void ResourceFormatLoaderCrypto::get_recognized_extensions(List<String> *p_extensions) const { … }

bool ResourceFormatLoaderCrypto::handles_type(const String &p_type) const { … }

String ResourceFormatLoaderCrypto::get_resource_type(const String &p_path) const { … }

Error ResourceFormatSaverCrypto::save(const Ref<Resource> &p_resource, const String &p_path, uint32_t p_flags) { … }

void ResourceFormatSaverCrypto::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const { … }

bool ResourceFormatSaverCrypto::recognize(const Ref<Resource> &p_resource) const { … }