GeezerVison

The World Wide Web, restored to 800 pixels of glory.

GeezerVison is showing github.com — src: shift more crypto impl details to ncrypto · nodejs/node@8daeccf

File tree

Expand file treeCollapse file tree

Open diff view settings

Filter options

deps/ncrypto
- ncrypto.cc
- ncrypto.h
src/crypto

Expand file treeCollapse file tree

Open diff view settings

Collapse file

`‎deps/ncrypto/ncrypto.cc‎`

Copy file name to clipboardExpand all lines: deps/ncrypto/ncrypto.cc

+437-23Lines changed: 437 additions & 23 deletions

Large diffs are not rendered by default.

Collapse file

`‎deps/ncrypto/ncrypto.h‎`

Copy file name to clipboardExpand all lines: deps/ncrypto/ncrypto.h

+83-15Lines changed: 83 additions & 15 deletions

Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,11 @@`
`1`	`1`	`#pragma once`
`2`	`2`
	`3`	`+#include <cstddef>`
`3`	`4`	`#include <list>`
`4`	`5`	`#include <memory>`
`5`	`6`	`#include <optional>`
`6`	`7`	`#include <string>`
`7`	`8`	`#include <string_view>`
`8`		`-#include <vector>`
`9`	`9`	`#include "openssl/bn.h"`
`10`	`10`	`#include <openssl/x509.h>`
`11`	`11`	`#include <openssl/dh.h>`
`@@ -82,6 +82,15 @@ namespace ncrypto {`
`82`	`82`	`void* operator new(size_t) = delete; \`
`83`	`83`	`void operator delete(void*) = delete;`
`84`	`84`
	`85`	`+[[noreturn]] inline void unreachable() {`
	`86`	`+#ifdef __GNUC__`
	`87`	`+ __builtin_unreachable();`
	`88`	`+#elif defined(_MSC_VER)`
	`89`	`+ __assume(false);`
	`90`	`+#else`
	`91`	`+#endif`
	`92`	`+}`
	`93`	`+`
`85`	`94`	`// ============================================================================`
`86`	`95`	`// Error handling utilities`
`87`	`96`
`@@ -190,30 +199,92 @@ using SSLPointer = DeleteFnPtr<SSL, SSL_free>;`
`190`	`199`	`using SSLSessionPointer = DeleteFnPtr<SSL_SESSION, SSL_SESSION_free>;`
`191`	`200`	`using X509Pointer = DeleteFnPtr<X509, X509_free>;`
`192`	`201`
	`202`	`+// An unowned, unmanaged pointer to a buffer of data.`
	`203`	`+template <typename T>`
	`204`	`+struct Buffer {`
	`205`	`+ T* data = nullptr;`
	`206`	`+ size_t len = 0;`
	`207`	`+};`
	`208`	`+`
	`209`	`+// A managed pointer to a buffer of data. When destroyed the underlying`
	`210`	`+// buffer will be freed.`
	`211`	`+class DataPointer final {`
	`212`	`+ public:`
	`213`	`+ static DataPointer Alloc(size_t len);`
	`214`	`+`
	`215`	`+ DataPointer() = default;`
	`216`	`+ explicit DataPointer(void* data, size_t len);`
	`217`	`+ explicit DataPointer(const Buffer<void>& buffer);`
	`218`	`+ DataPointer(DataPointer&& other) noexcept;`
	`219`	`+ DataPointer& operator=(DataPointer&& other) noexcept;`
	`220`	`+ NCRYPTO_DISALLOW_COPY(DataPointer)`
	`221`	`+ ~DataPointer();`
	`222`	`+`
	`223`	`+ inline bool operator==(std::nullptr_t) noexcept { return data_ == nullptr; }`
	`224`	`+ inline operator bool() const { return data_ != nullptr; }`
	`225`	`+ inline void* get() const noexcept { return data_; }`
	`226`	`+ inline size_t size() const noexcept { return len_; }`
	`227`	`+ void reset(void* data = nullptr, size_t len = 0);`
	`228`	`+ void reset(const Buffer<void>& buffer);`
	`229`	`+`
	`230`	`+ // Releases ownership of the underlying data buffer. It is the caller's`
	`231`	`+ // responsibility to ensure the buffer is appropriately freed.`
	`232`	`+ Buffer<void> release();`
	`233`	`+`
	`234`	`+ // Returns a Buffer struct that is a view of the underlying data.`
	`235`	`+ inline operator const Buffer<void>() const {`
	`236`	`+ return {`
	`237`	`+ .data = data_,`
	`238`	`+ .len = len_,`
	`239`	`+ };`
	`240`	`+ }`
	`241`	`+`
	`242`	`+ private:`
	`243`	`+ void* data_ = nullptr;`
	`244`	`+ size_t len_ = 0;`
	`245`	`+};`
	`246`	`+`
`193`	`247`	`class BignumPointer final {`
`194`	`248`	`public:`
`195`	`249`	`BignumPointer() = default;`
`196`	`250`	`explicit BignumPointer(BIGNUM* bignum);`
	`251`	`+ explicit BignumPointer(const unsigned char* data, size_t len);`
`197`	`252`	`BignumPointer(BignumPointer&& other) noexcept;`
`198`	`253`	`BignumPointer& operator=(BignumPointer&& other) noexcept;`
`199`	`254`	`NCRYPTO_DISALLOW_COPY(BignumPointer)`
`200`	`255`	`~BignumPointer();`
`201`	`256`
`202`		`- bool operator==(const BignumPointer& other) noexcept;`
`203`		`- bool operator==(const BIGNUM* other) noexcept;`
`204`		`- inline bool operator==(std::nullptr_t) noexcept { return bn_ == nullptr; }`
	`257`	`+ int operator<=>(const BignumPointer& other) const noexcept;`
	`258`	`+ int operator<=>(const BIGNUM* other) const noexcept;`
`205`	`259`	`inline operator bool() const { return bn_ != nullptr; }`
`206`	`260`	`inline BIGNUM* get() const noexcept { return bn_.get(); }`
`207`	`261`	`void reset(BIGNUM* bn = nullptr);`
	`262`	`+ void reset(const unsigned char* data, size_t len);`
`208`	`263`	`BIGNUM* release();`
`209`	`264`
`210`		`- size_t byteLength();`
	`265`	`+ bool isZero() const;`
	`266`	`+ bool isOne() const;`
`211`	`267`
`212`		`- std::vector<uint8_t> encode();`
`213`		`- std::vector<uint8_t> encodePadded(size_t size);`
	`268`	`+ bool setWord(unsigned long w);`
	`269`	`+ unsigned long getWord() const;`
`214`	`270`
`215`		`- static std::vector<uint8_t> encode(const BIGNUM* bn);`
`216`		`- static std::vector<uint8_t> encodePadded(const BIGNUM* bn, size_t size);`
	`271`	`+ size_t byteLength() const;`
	`272`	`+`
	`273`	`+ DataPointer toHex() const;`
	`274`	`+ DataPointer encode() const;`
	`275`	`+ DataPointer encodePadded(size_t size) const;`
	`276`	`+ size_t encodeInto(unsigned char* out) const;`
	`277`	`+ size_t encodePaddedInto(unsigned char* out, size_t size) const;`
	`278`	`+`
	`279`	`+ static BignumPointer New();`
	`280`	`+ static BignumPointer NewSecure();`
	`281`	`+ static DataPointer Encode(const BIGNUM* bn);`
	`282`	`+ static DataPointer EncodePadded(const BIGNUM* bn, size_t size);`
	`283`	`+ static size_t EncodePaddedInto(const BIGNUM* bn, unsigned char* out, size_t size);`
	`284`	`+ static int GetBitCount(const BIGNUM* bn);`
	`285`	`+ static int GetByteCount(const BIGNUM* bn);`
	`286`	`+ static unsigned long GetWord(const BIGNUM* bn);`
	`287`	`+ static const BIGNUM* One();`
`217`	`288`
`218`	`289`	`private:`
`219`	`290`	`DeleteFnPtr<BIGNUM, BN_clear_free> bn_;`
`@@ -269,12 +340,6 @@ bool testFipsEnabled();`
`269`	`340`	`// ============================================================================`
`270`	`341`	`// Various utilities`
`271`	`342`
`272`		`-template <typename T>`
`273`		`-struct Buffer {`
`274`		`- T* data = nullptr;`
`275`		`- size_t len = 0;`
`276`		`-};`
`277`		`-`
`278`	`343`	`bool CSPRNG(void* buffer, size_t length) NCRYPTO_MUST_USE_RESULT;`
`279`	`344`
`280`	`345`	`// This callback is used to avoid the default passphrase callback in OpenSSL`
`@@ -286,6 +351,9 @@ int NoPasswordCallback(char* buf, int size, int rwflag, void* u);`
`286`	`351`
`287`	`352`	`int PasswordCallback(char* buf, int size, int rwflag, void* u);`
`288`	`353`
	`354`	`+bool SafeX509SubjectAltNamePrint(const BIOPointer& out, X509_EXTENSION* ext);`
	`355`	`+bool SafeX509InfoAccessPrint(const BIOPointer& out, X509_EXTENSION* ext);`
	`356`	`+`
`289`	`357`	`// ============================================================================`
`290`	`358`	`// SPKAC`
`291`	`359`

Collapse file

`‎src/crypto/crypto_aes.cc‎`

Copy file name to clipboardExpand all lines: src/crypto/crypto_aes.cc

+10-15Lines changed: 10 additions & 15 deletions

Original file line number	Diff line number	Diff line change
`@@ -185,10 +185,7 @@ BignumPointer GetCounter(const AESCipherConfig& params) {`
`185`	`185`
`186`	`186`	`if (remainder == 0) {`
`187`	`187`	`unsigned int byte_length = params.length / CHAR_BIT;`
`188`		`- return BignumPointer(BN_bin2bn(`
`189`		`- data + params.iv.size() - byte_length,`
`190`		`- byte_length,`
`191`		`- nullptr));`
	`188`	`+ return BignumPointer(data + params.iv.size() - byte_length, byte_length);`
`192`	`189`	`}`
`193`	`190`
`194`	`191`	`unsigned int byte_length =`
`@@ -199,7 +196,7 @@ BignumPointer GetCounter(const AESCipherConfig& params) {`
`199`	`196`	`data + params.iv.size());`
`200`	`197`	`counter[0] &= ~(0xFF << remainder);`
`201`	`198`
`202`		`- return BignumPointer(BN_bin2bn(counter.data(), counter.size(), nullptr));`
	`199`	`+ return BignumPointer(counter.data(), counter.size());`
`203`	`200`	`}`
`204`	`201`
`205`	`202`	`std::vector<unsigned char> BlockWithZeroedCounter(`
`@@ -269,23 +266,22 @@ WebCryptoCipherStatus AES_CTR_Cipher(`
`269`	`266`	`const AESCipherConfig& params,`
`270`	`267`	`const ByteSource& in,`
`271`	`268`	`ByteSource* out) {`
`272`		`- BignumPointer num_counters(BN_new());`
`273`		`- if (!BN_lshift(num_counters.get(), BN_value_one(), params.length))`
	`269`	`+ auto num_counters = BignumPointer::New();`
	`270`	`+ if (!BN_lshift(num_counters.get(), BignumPointer::One(), params.length))`
`274`	`271`	`return WebCryptoCipherStatus::FAILED;`
`275`	`272`
`276`	`273`	`BignumPointer current_counter = GetCounter(params);`
`277`	`274`
`278`		`- BignumPointer num_output(BN_new());`
	`275`	`+ auto num_output = BignumPointer::New();`
`279`	`276`
`280`		`- if (!BN_set_word(num_output.get(), CeilDiv(in.size(), kAesBlockSize)))`
	`277`	`+ if (!num_output.setWord(CeilDiv(in.size(), kAesBlockSize)))`
`281`	`278`	`return WebCryptoCipherStatus::FAILED;`
`282`	`279`
`283`	`280`	`// Just like in chromium's implementation, if the counter will`
`284`	`281`	`// be incremented more than there are counter values, we fail.`
`285`		`- if (BN_cmp(num_output.get(), num_counters.get()) > 0)`
`286`		`- return WebCryptoCipherStatus::FAILED;`
	`282`	`+ if (num_output > num_counters) return WebCryptoCipherStatus::FAILED;`
`287`	`283`
`288`		`- BignumPointer remaining_until_reset(BN_new());`
	`284`	`+ auto remaining_until_reset = BignumPointer::New();`
`289`	`285`	`if (!BN_sub(remaining_until_reset.get(),`
`290`	`286`	`num_counters.get(),`
`291`	`287`	`current_counter.get())) {`
`@@ -298,7 +294,7 @@ WebCryptoCipherStatus AES_CTR_Cipher(`
`298`	`294`	`// Also just like in chromium's implementation, if we can process`
`299`	`295`	`// the input without wrapping the counter, we'll do it as a single`
`300`	`296`	`// call here. If we can't, we'll fallback to the a two-step approach`
`301`		`- if (BN_cmp(remaining_until_reset.get(), num_output.get()) >= 0) {`
	`297`	`+ if (remaining_until_reset >= num_output) {`
`302`	`298`	`auto status = AES_CTR_Cipher2(key_data,`
`303`	`299`	`cipher_mode,`
`304`	`300`	`params,`
`@@ -309,8 +305,7 @@ WebCryptoCipherStatus AES_CTR_Cipher(`
`309`	`305`	`return status;`
`310`	`306`	`}`
`311`	`307`
`312`		`- BN_ULONG blocks_part1 = BN_get_word(remaining_until_reset.get());`
`313`		`- BN_ULONG input_size_part1 = blocks_part1 * kAesBlockSize;`
	`308`	`+ BN_ULONG input_size_part1 = remaining_until_reset.getWord() * kAesBlockSize;`
`314`	`309`
`315`	`310`	`// Encrypt the first part...`
`316`	`311`	`auto status =`

0 commit comments

Comments

0 (0)

You are visitor 01402503 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.