diff options
| author | avi <avi@chromium.org> | 2015-12-21 13:34:43 -0800 |
|---|---|---|
| committer | Commit bot <commit-bot@chromium.org> | 2015-12-21 21:35:49 +0000 |
| commit | dd373b8b7d7501cf7f3bbfe861f58dce67578a69 (patch) | |
| tree | 037d2922a3dc5079e1eff59e9a3eb5fe3c605fa0 /crypto | |
| parent | 64114156487081d877b793d3a501a8658743141d (diff) | |
| download | chromium_src-dd373b8b7d7501cf7f3bbfe861f58dce67578a69.zip chromium_src-dd373b8b7d7501cf7f3bbfe861f58dce67578a69.tar.gz chromium_src-dd373b8b7d7501cf7f3bbfe861f58dce67578a69.tar.bz2 | |
Switch to standard integer types in crypto/.
BUG=138542
TBR=rsleevi@chromium.org
NOPRESUBMIT=true
Review URL: https://codereview.chromium.org/1539353003
Cr-Commit-Position: refs/heads/master@{#366460}
Diffstat (limited to 'crypto')
82 files changed, 1051 insertions, 1010 deletions
diff --git a/crypto/aead_openssl.cc b/crypto/aead_openssl.cc index 54795b8..7249421 100644 --- a/crypto/aead_openssl.cc +++ b/crypto/aead_openssl.cc @@ -8,9 +8,10 @@ #include <openssl/aes.h> #include <openssl/evp.h> +#include <stddef.h> +#include <stdint.h> #include <string> -#include "base/basictypes.h" #include "base/strings/string_util.h" #include "crypto/openssl_util.h" @@ -43,7 +44,7 @@ bool Aead::Seal(const base::StringPiece& plaintext, EVP_AEAD_CTX ctx; if (!EVP_AEAD_CTX_init(&ctx, aead_, - reinterpret_cast<const uint8*>(key_->data()), + reinterpret_cast<const uint8_t*>(key_->data()), key_->size(), EVP_AEAD_DEFAULT_TAG_LENGTH, nullptr)) { return false; } @@ -52,14 +53,14 @@ bool Aead::Seal(const base::StringPiece& plaintext, const size_t max_output_length = EVP_AEAD_max_overhead(aead_) + plaintext.size(); size_t output_length; - uint8* out_ptr = - reinterpret_cast<uint8*>(base::WriteInto(&result, max_output_length + 1)); + uint8_t* out_ptr = reinterpret_cast<uint8_t*>( + base::WriteInto(&result, max_output_length + 1)); if (!EVP_AEAD_CTX_seal( &ctx, out_ptr, &output_length, max_output_length, - reinterpret_cast<const uint8*>(nonce.data()), nonce.size(), - reinterpret_cast<const uint8*>(plaintext.data()), plaintext.size(), - reinterpret_cast<const uint8*>(additional_data.data()), + reinterpret_cast<const uint8_t*>(nonce.data()), nonce.size(), + reinterpret_cast<const uint8_t*>(plaintext.data()), plaintext.size(), + reinterpret_cast<const uint8_t*>(additional_data.data()), additional_data.size())) { EVP_AEAD_CTX_cleanup(&ctx); return false; @@ -82,7 +83,7 @@ bool Aead::Open(const base::StringPiece& ciphertext, EVP_AEAD_CTX ctx; if (!EVP_AEAD_CTX_init(&ctx, aead_, - reinterpret_cast<const uint8*>(key_->data()), + reinterpret_cast<const uint8_t*>(key_->data()), key_->size(), EVP_AEAD_DEFAULT_TAG_LENGTH, nullptr)) { return false; } @@ -90,14 +91,15 @@ bool Aead::Open(const base::StringPiece& ciphertext, std::string result; const size_t max_output_length = ciphertext.size(); size_t output_length; - uint8* out_ptr = - reinterpret_cast<uint8*>(base::WriteInto(&result, max_output_length + 1)); + uint8_t* out_ptr = reinterpret_cast<uint8_t*>( + base::WriteInto(&result, max_output_length + 1)); if (!EVP_AEAD_CTX_open( &ctx, out_ptr, &output_length, max_output_length, - reinterpret_cast<const uint8*>(nonce.data()), nonce.size(), - reinterpret_cast<const uint8*>(ciphertext.data()), ciphertext.size(), - reinterpret_cast<const uint8*>(additional_data.data()), + reinterpret_cast<const uint8_t*>(nonce.data()), nonce.size(), + reinterpret_cast<const uint8_t*>(ciphertext.data()), + ciphertext.size(), + reinterpret_cast<const uint8_t*>(additional_data.data()), additional_data.size())) { EVP_AEAD_CTX_cleanup(&ctx); return false; diff --git a/crypto/aead_openssl.h b/crypto/aead_openssl.h index 773cce1..3ba6041 100644 --- a/crypto/aead_openssl.h +++ b/crypto/aead_openssl.h @@ -5,6 +5,8 @@ #ifndef CRYPTO_AEAD_H_ #define CRYPTO_AEAD_H_ +#include <stddef.h> + #include "base/strings/string_piece.h" #include "crypto/crypto_export.h" diff --git a/crypto/apple_keychain.h b/crypto/apple_keychain.h index 840ccee8..1ea2473 100644 --- a/crypto/apple_keychain.h +++ b/crypto/apple_keychain.h @@ -7,7 +7,8 @@ #include <Security/Security.h> -#include "base/basictypes.h" +#include "base/macros.h" +#include "build/build_config.h" #include "crypto/crypto_export.h" #if defined (OS_IOS) diff --git a/crypto/capi_util.cc b/crypto/capi_util.cc index 1a3e139..7adfeb8 100644 --- a/crypto/capi_util.cc +++ b/crypto/capi_util.cc @@ -4,7 +4,9 @@ #include "crypto/capi_util.h" -#include "base/basictypes.h" +#include <stddef.h> + +#include "base/macros.h" #include "base/memory/singleton.h" #include "base/synchronization/lock.h" diff --git a/crypto/capi_util.h b/crypto/capi_util.h index 9d43293..6941033 100644 --- a/crypto/capi_util.h +++ b/crypto/capi_util.h @@ -6,6 +6,7 @@ #define CRYPTO_CAPI_UTIL_H_ #include <windows.h> +#include <stddef.h> #include "crypto/crypto_export.h" #include "crypto/wincrypt_shim.h" diff --git a/crypto/cssm_init.cc b/crypto/cssm_init.cc index 495e71b..6fa585a 100644 --- a/crypto/cssm_init.cc +++ b/crypto/cssm_init.cc @@ -5,6 +5,7 @@ #include "crypto/cssm_init.h" #include <Security/SecBase.h> +#include <stdint.h> #include "base/logging.h" #include "base/mac/scoped_cftyperef.h" @@ -32,7 +33,7 @@ void* CSSMRealloc(void* ptr, CSSM_SIZE size, void* alloc_ref) { return realloc(ptr, size); } -void* CSSMCalloc(uint32 num, CSSM_SIZE size, void* alloc_ref) { +void* CSSMCalloc(uint32_t num, CSSM_SIZE size, void* alloc_ref) { return calloc(num, size); } diff --git a/crypto/cssm_init.h b/crypto/cssm_init.h index e711099..3eece1b 100644 --- a/crypto/cssm_init.h +++ b/crypto/cssm_init.h @@ -7,7 +7,7 @@ #include <Security/cssm.h> -#include "base/basictypes.h" +#include "base/macros.h" #include "crypto/crypto_export.h" namespace crypto { diff --git a/crypto/curve25519_nss.cc b/crypto/curve25519_nss.cc index 746356f..88bf94c 100644 --- a/crypto/curve25519_nss.cc +++ b/crypto/curve25519_nss.cc @@ -4,6 +4,8 @@ #include "crypto/curve25519.h" +#include <stdint.h> + #include "crypto/secure_util.h" // Curve25519 is specified in terms of byte strings, not numbers, so all diff --git a/crypto/curve25519_openssl.cc b/crypto/curve25519_openssl.cc index 067e19c..06c2f01 100644 --- a/crypto/curve25519_openssl.cc +++ b/crypto/curve25519_openssl.cc @@ -5,6 +5,7 @@ #include "crypto/curve25519.h" #include <openssl/curve25519.h> +#include <stdint.h> namespace crypto { diff --git a/crypto/curve25519_unittest.cc b/crypto/curve25519_unittest.cc index 48144ba..15a9981 100644 --- a/crypto/curve25519_unittest.cc +++ b/crypto/curve25519_unittest.cc @@ -4,6 +4,8 @@ #include "crypto/curve25519.h" +#include <stdint.h> + #include <string> #include "crypto/random.h" diff --git a/crypto/ec_private_key.h b/crypto/ec_private_key.h index a3ba49d..9a8a02a 100644 --- a/crypto/ec_private_key.h +++ b/crypto/ec_private_key.h @@ -5,10 +5,13 @@ #ifndef CRYPTO_EC_PRIVATE_KEY_H_ #define CRYPTO_EC_PRIVATE_KEY_H_ +#include <stddef.h> +#include <stdint.h> + #include <string> #include <vector> -#include "base/basictypes.h" +#include "base/macros.h" #include "build/build_config.h" #include "crypto/crypto_export.h" @@ -45,8 +48,8 @@ class CRYPTO_EXPORT ECPrivateKey { // Returns NULL if initialization fails. static ECPrivateKey* CreateFromEncryptedPrivateKeyInfo( const std::string& password, - const std::vector<uint8>& encrypted_private_key_info, - const std::vector<uint8>& subject_public_key_info); + const std::vector<uint8_t>& encrypted_private_key_info, + const std::vector<uint8_t>& subject_public_key_info); #if !defined(USE_OPENSSL) // Imports the key pair into |slot| and returns in |public_key| and |key|. @@ -56,7 +59,7 @@ class CRYPTO_EXPORT ECPrivateKey { static bool ImportFromEncryptedPrivateKeyInfo( PK11SlotInfo* slot, const std::string& password, - const uint8* encrypted_private_key_info, + const uint8_t* encrypted_private_key_info, size_t encrypted_private_key_info_len, CERTSubjectPublicKeyInfo* decoded_spki, bool permanent, @@ -82,18 +85,18 @@ class CRYPTO_EXPORT ECPrivateKey { // of 1000 iterations, on modern systems a larger value may be preferrable. bool ExportEncryptedPrivateKey(const std::string& password, int iterations, - std::vector<uint8>* output); + std::vector<uint8_t>* output); // Exports the public key to an X.509 SubjectPublicKeyInfo block. - bool ExportPublicKey(std::vector<uint8>* output); + bool ExportPublicKey(std::vector<uint8_t>* output); // Exports the public key as an EC point in the uncompressed point format. bool ExportRawPublicKey(std::string* output); // Exports private key data for testing. The format of data stored into output // doesn't matter other than that it is consistent for the same key. - bool ExportValue(std::vector<uint8>* output); - bool ExportECParams(std::vector<uint8>* output); + bool ExportValue(std::vector<uint8_t>* output); + bool ExportECParams(std::vector<uint8_t>* output); private: // Constructor is private. Use one of the Create*() methods above instead. diff --git a/crypto/ec_private_key_nss.cc b/crypto/ec_private_key_nss.cc index 5f8a4e6..b65de95 100644 --- a/crypto/ec_private_key_nss.cc +++ b/crypto/ec_private_key_nss.cc @@ -14,6 +14,8 @@ extern "C" { #include <keyhi.h> #include <pk11pub.h> #include <secmod.h> +#include <stddef.h> +#include <stdint.h> #include "base/logging.h" #include "base/memory/scoped_ptr.h" @@ -27,7 +29,7 @@ namespace { // Copied from rsa_private_key_nss.cc. static bool ReadAttribute(SECKEYPrivateKey* key, CK_ATTRIBUTE_TYPE type, - std::vector<uint8>* output) { + std::vector<uint8_t>* output) { SECItem item; SECStatus rv; rv = PK11_ReadRawAttribute(PK11_TypePrivKey, key, type, &item); @@ -102,8 +104,8 @@ ECPrivateKey* ECPrivateKey::Create() { // static ECPrivateKey* ECPrivateKey::CreateFromEncryptedPrivateKeyInfo( const std::string& password, - const std::vector<uint8>& encrypted_private_key_info, - const std::vector<uint8>& subject_public_key_info) { + const std::vector<uint8_t>& encrypted_private_key_info, + const std::vector<uint8_t>& subject_public_key_info) { EnsureNSSInit(); ScopedPK11Slot slot(PK11_GetInternalSlot()); @@ -149,7 +151,7 @@ ECPrivateKey* ECPrivateKey::CreateFromEncryptedPrivateKeyInfo( bool ECPrivateKey::ImportFromEncryptedPrivateKeyInfo( PK11SlotInfo* slot, const std::string& password, - const uint8* encrypted_private_key_info, + const uint8_t* encrypted_private_key_info, size_t encrypted_private_key_info_len, CERTSubjectPublicKeyInfo* decoded_spki, bool permanent, @@ -237,10 +239,9 @@ ECPrivateKey* ECPrivateKey::Copy() const { return copy.release(); } -bool ECPrivateKey::ExportEncryptedPrivateKey( - const std::string& password, - int iterations, - std::vector<uint8>* output) { +bool ECPrivateKey::ExportEncryptedPrivateKey(const std::string& password, + int iterations, + std::vector<uint8_t>* output) { // We export as an EncryptedPrivateKeyInfo bundle instead of a plain PKCS #8 // PrivateKeyInfo because PK11_ImportDERPrivateKeyInfoAndReturnKey doesn't // support EC keys. @@ -282,7 +283,7 @@ bool ECPrivateKey::ExportEncryptedPrivateKey( return true; } -bool ECPrivateKey::ExportPublicKey(std::vector<uint8>* output) { +bool ECPrivateKey::ExportPublicKey(std::vector<uint8_t>* output) { ScopedSECItem der_pubkey( SECKEY_EncodeDERSubjectPublicKeyInfo(public_key_)); if (!der_pubkey.get()) { @@ -310,11 +311,11 @@ bool ECPrivateKey::ExportRawPublicKey(std::string* output) { return true; } -bool ECPrivateKey::ExportValue(std::vector<uint8>* output) { +bool ECPrivateKey::ExportValue(std::vector<uint8_t>* output) { return ReadAttribute(key_, CKA_VALUE, output); } -bool ECPrivateKey::ExportECParams(std::vector<uint8>* output) { +bool ECPrivateKey::ExportECParams(std::vector<uint8_t>* output) { return ReadAttribute(key_, CKA_EC_PARAMS, output); } diff --git a/crypto/ec_private_key_openssl.cc b/crypto/ec_private_key_openssl.cc index 9836fa6..d896203 100644 --- a/crypto/ec_private_key_openssl.cc +++ b/crypto/ec_private_key_openssl.cc @@ -8,6 +8,8 @@ #include <openssl/evp.h> #include <openssl/pkcs12.h> #include <openssl/x509.h> +#include <stddef.h> +#include <stdint.h> #include "base/logging.h" #include "base/memory/scoped_ptr.h" @@ -32,7 +34,7 @@ using ScopedX509_SIG = ScopedOpenSSL<X509_SIG, X509_SIG_free>; // Helper to export |key| into |output| via the specified ExportBioFunction. bool ExportKeyWithBio(const void* key, ExportBioFunction export_fn, - std::vector<uint8>* output) { + std::vector<uint8_t>* output) { if (!key) return false; @@ -62,7 +64,7 @@ typedef int (*ExportDataFunction)(const void* key, unsigned char** data); // Helper to export |key| into |output| via the specified export function. bool ExportKey(const void* key, ExportDataFunction export_fn, - std::vector<uint8>* output) { + std::vector<uint8_t>* output) { if (!key) return false; @@ -112,8 +114,8 @@ ECPrivateKey* ECPrivateKey::Create() { // static ECPrivateKey* ECPrivateKey::CreateFromEncryptedPrivateKeyInfo( const std::string& password, - const std::vector<uint8>& encrypted_private_key_info, - const std::vector<uint8>& subject_public_key_info) { + const std::vector<uint8_t>& encrypted_private_key_info, + const std::vector<uint8_t>& subject_public_key_info) { // NOTE: The |subject_public_key_info| can be ignored here, it is only // useful for the NSS implementation (which uses the public key's SHA1 // as a lookup key when storing the private one in its store). @@ -157,10 +159,9 @@ ECPrivateKey* ECPrivateKey::CreateFromEncryptedPrivateKeyInfo( return result.release(); } -bool ECPrivateKey::ExportEncryptedPrivateKey( - const std::string& password, - int iterations, - std::vector<uint8>* output) { +bool ECPrivateKey::ExportEncryptedPrivateKey(const std::string& password, + int iterations, + std::vector<uint8_t>* output) { OpenSSLErrStackTracer err_tracer(FROM_HERE); // Convert into a PKCS#8 object. ScopedPKCS8_PRIV_KEY_INFO pkcs8(EVP_PKEY2PKCS8(key_)); @@ -189,7 +190,7 @@ bool ECPrivateKey::ExportEncryptedPrivateKey( output); } -bool ECPrivateKey::ExportPublicKey(std::vector<uint8>* output) { +bool ECPrivateKey::ExportPublicKey(std::vector<uint8_t>* output) { OpenSSLErrStackTracer err_tracer(FROM_HERE); return ExportKeyWithBio( key_, reinterpret_cast<ExportBioFunction>(i2d_PUBKEY_bio), output); @@ -205,8 +206,8 @@ bool ECPrivateKey::ExportRawPublicKey(std::string* output) { if (len != kExpectedKeyLength) return false; - uint8 buf[kExpectedKeyLength]; - uint8* derp = buf; + uint8_t buf[kExpectedKeyLength]; + uint8_t* derp = buf; len = i2d_PublicKey(key_, &derp); if (len != kExpectedKeyLength) return false; @@ -215,7 +216,7 @@ bool ECPrivateKey::ExportRawPublicKey(std::string* output) { return true; } -bool ECPrivateKey::ExportValue(std::vector<uint8>* output) { +bool ECPrivateKey::ExportValue(std::vector<uint8_t>* output) { OpenSSLErrStackTracer err_tracer(FROM_HERE); ScopedEC_KEY ec_key(EVP_PKEY_get1_EC_KEY(key_)); return ExportKey(ec_key.get(), @@ -223,7 +224,7 @@ bool ECPrivateKey::ExportValue(std::vector<uint8>* output) { output); } -bool ECPrivateKey::ExportECParams(std::vector<uint8>* output) { +bool ECPrivateKey::ExportECParams(std::vector<uint8_t>* output) { OpenSSLErrStackTracer err_tracer(FROM_HERE); ScopedEC_KEY ec_key(EVP_PKEY_get1_EC_KEY(key_)); return ExportKey(ec_key.get(), diff --git a/crypto/ec_private_key_unittest.cc b/crypto/ec_private_key_unittest.cc index cfd08f2..57af82e 100644 --- a/crypto/ec_private_key_unittest.cc +++ b/crypto/ec_private_key_unittest.cc @@ -4,6 +4,8 @@ #include "crypto/ec_private_key.h" +#include <stdint.h> + #include <vector> #include "base/macros.h" @@ -22,19 +24,19 @@ TEST(ECPrivateKeyUnitTest, InitRandomTest) { ASSERT_TRUE(keypair1.get()); ASSERT_TRUE(keypair2.get()); - std::vector<uint8> key1value; - std::vector<uint8> key2value; - std::vector<uint8> key1params; - std::vector<uint8> key2params; + std::vector<uint8_t> key1value; + std::vector<uint8_t> key2value; + std::vector<uint8_t> key1params; + std::vector<uint8_t> key2params; EXPECT_TRUE(keypair1->ExportValue(&key1value)); EXPECT_TRUE(keypair2->ExportValue(&key2value)); EXPECT_TRUE(keypair1->ExportECParams(&key1params)); EXPECT_TRUE(keypair2->ExportECParams(&key2params)); - std::vector<uint8> privkey1; - std::vector<uint8> privkey2; - std::vector<uint8> pubkey1; - std::vector<uint8> pubkey2; + std::vector<uint8_t> privkey1; + std::vector<uint8_t> privkey2; + std::vector<uint8_t> pubkey1; + std::vector<uint8_t> pubkey2; std::string raw_pubkey1; std::string raw_pubkey2; ASSERT_TRUE(keypair1->ExportEncryptedPrivateKey(password1, 1, &privkey1)); @@ -53,10 +55,10 @@ TEST(ECPrivateKeyUnitTest, InitRandomTest) { ASSERT_TRUE(keypair3.get()); ASSERT_TRUE(keypair4.get()); - std::vector<uint8> key3value; - std::vector<uint8> key4value; - std::vector<uint8> key3params; - std::vector<uint8> key4params; + std::vector<uint8_t> key3value; + std::vector<uint8_t> key4value; + std::vector<uint8_t> key3params; + std::vector<uint8_t> key4params; EXPECT_TRUE(keypair3->ExportValue(&key3value)); EXPECT_TRUE(keypair4->ExportValue(&key4value)); EXPECT_TRUE(keypair3->ExportECParams(&key3params)); @@ -67,8 +69,8 @@ TEST(ECPrivateKeyUnitTest, InitRandomTest) { EXPECT_EQ(key1params, key3params); EXPECT_EQ(key2params, key4params); - std::vector<uint8> pubkey3; - std::vector<uint8> pubkey4; + std::vector<uint8_t> pubkey3; + std::vector<uint8_t> pubkey4; std::string raw_pubkey3; std::string raw_pubkey4; EXPECT_TRUE(keypair3->ExportPublicKey(&pubkey3)); @@ -88,20 +90,20 @@ TEST(ECPrivateKeyUnitTest, Copy) { ASSERT_TRUE(keypair1.get()); ASSERT_TRUE(keypair2.get()); - std::vector<uint8> key1value; - std::vector<uint8> key2value; + std::vector<uint8_t> key1value; + std::vector<uint8_t> key2value; EXPECT_TRUE(keypair1->ExportValue(&key1value)); EXPECT_TRUE(keypair2->ExportValue(&key2value)); EXPECT_EQ(key1value, key2value); - std::vector<uint8> key1params; - std::vector<uint8> key2params; + std::vector<uint8_t> key1params; + std::vector<uint8_t> key2params; EXPECT_TRUE(keypair1->ExportECParams(&key1params)); EXPECT_TRUE(keypair2->ExportECParams(&key2params)); EXPECT_EQ(key1params, key2params); - std::vector<uint8> pubkey1; - std::vector<uint8> pubkey2; + std::vector<uint8_t> pubkey1; + std::vector<uint8_t> pubkey2; EXPECT_TRUE(keypair1->ExportPublicKey(&pubkey1)); EXPECT_TRUE(keypair2->ExportPublicKey(&pubkey2)); EXPECT_EQ(pubkey1, pubkey2); @@ -121,8 +123,8 @@ TEST(ECPrivateKeyUnitTest, BadPasswordTest) { crypto::ECPrivateKey::Create()); ASSERT_TRUE(keypair1.get()); - std::vector<uint8> privkey1; - std::vector<uint8> pubkey1; + std::vector<uint8_t> privkey1; + std::vector<uint8_t> pubkey1; ASSERT_TRUE(keypair1->ExportEncryptedPrivateKey( password1, 1, &privkey1)); ASSERT_TRUE(keypair1->ExportPublicKey(&pubkey1)); @@ -163,10 +165,9 @@ TEST(ECPrivateKeyUnitTest, LoadNSSKeyTest) { scoped_ptr<crypto::ECPrivateKey> keypair_nss( crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo( - "", - std::vector<uint8>(nss_key, nss_key + arraysize(nss_key)), - std::vector<uint8>(nss_pub_key, - nss_pub_key + arraysize(nss_pub_key)))); + "", std::vector<uint8_t>(nss_key, nss_key + arraysize(nss_key)), + std::vector<uint8_t>(nss_pub_key, + nss_pub_key + arraysize(nss_pub_key)))); EXPECT_TRUE(keypair_nss.get()); } @@ -202,10 +203,10 @@ TEST(ECPrivateKeyUnitTest, LoadOpenSSLKeyTest) { scoped_ptr<crypto::ECPrivateKey> keypair_openssl( crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo( - "", - std::vector<uint8>(openssl_key, openssl_key + arraysize(openssl_key)), - std::vector<uint8>(openssl_pub_key, - openssl_pub_key + arraysize(openssl_pub_key)))); + "", std::vector<uint8_t>(openssl_key, + openssl_key + arraysize(openssl_key)), + std::vector<uint8_t>(openssl_pub_key, + openssl_pub_key + arraysize(openssl_pub_key)))); EXPECT_TRUE(keypair_openssl.get()); } @@ -284,10 +285,10 @@ TEST(ECPrivateKeyUnitTest, LoadOldOpenSSLKeyTest) { scoped_ptr<crypto::ECPrivateKey> keypair_openssl( crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo( - "", - std::vector<uint8>(openssl_key, openssl_key + arraysize(openssl_key)), - std::vector<uint8>(openssl_pub_key, - openssl_pub_key + arraysize(openssl_pub_key)))); + "", std::vector<uint8_t>(openssl_key, + openssl_key + arraysize(openssl_key)), + std::vector<uint8_t>(openssl_pub_key, + openssl_pub_key + arraysize(openssl_pub_key)))); EXPECT_TRUE(keypair_openssl.get()); } diff --git a/crypto/ec_signature_creator.h b/crypto/ec_signature_creator.h index 16e64f5..47128fe 100644 --- a/crypto/ec_signature_creator.h +++ b/crypto/ec_signature_creator.h @@ -5,10 +5,11 @@ #ifndef CRYPTO_EC_SIGNATURE_CREATOR_H_ #define CRYPTO_EC_SIGNATURE_CREATOR_H_ +#include <stdint.h> + #include <string> #include <vector> -#include "base/basictypes.h" #include "crypto/crypto_export.h" namespace crypto { @@ -48,17 +49,17 @@ class CRYPTO_EXPORT ECSignatureCreator { // ECDSA-Sig-Value ::= SEQUENCE { // r INTEGER, // s INTEGER } - virtual bool Sign(const uint8* data, + virtual bool Sign(const uint8_t* data, int data_len, - std::vector<uint8>* signature) = 0; + std::vector<uint8_t>* signature) = 0; // DecodeSignature converts from a DER encoded ECDSA-Sig-Value (as produced // by Sign) to a `raw' ECDSA signature which consists of a pair of // big-endian, zero-padded, 256-bit integers, r and s. On success it returns // true and puts the raw signature into |out_raw_sig|. // (Only P-256 signatures are supported.) - virtual bool DecodeSignature(const std::vector<uint8>& signature, - std::vector<uint8>* out_raw_sig) = 0; + virtual bool DecodeSignature(const std::vector<uint8_t>& signature, + std::vector<uint8_t>* out_raw_sig) = 0; }; } // namespace crypto diff --git a/crypto/ec_signature_creator_impl.h b/crypto/ec_signature_creator_impl.h index 95e22e8..21614f8 100644 --- a/crypto/ec_signature_creator_impl.h +++ b/crypto/ec_signature_creator_impl.h @@ -5,7 +5,10 @@ #ifndef CRYPTO_EC_SIGNATURE_CREATOR_IMPL_H_ #define CRYPTO_EC_SIGNATURE_CREATOR_IMPL_H_ +#include <stdint.h> + #include "base/compiler_specific.h" +#include "base/macros.h" #include "crypto/ec_signature_creator.h" namespace crypto { @@ -15,12 +18,12 @@ class ECSignatureCreatorImpl : public ECSignatureCreator { explicit ECSignatureCreatorImpl(ECPrivateKey* key); ~ECSignatureCreatorImpl() override; - bool Sign(const uint8* data, + bool Sign(const uint8_t* data, int data_len, - std::vector<uint8>* signature) override; + std::vector<uint8_t>* signature) override; - bool DecodeSignature(const std::vector<uint8>& der_sig, - std::vector<uint8>* out_raw_sig) override; + bool DecodeSignature(const std::vector<uint8_t>& der_sig, + std::vector<uint8_t>* out_raw_sig) override; private: ECPrivateKey* key_; diff --git a/crypto/ec_signature_creator_nss.cc b/crypto/ec_signature_creator_nss.cc index 06a0ad5..7c8cc7d 100644 --- a/crypto/ec_signature_creator_nss.cc +++ b/crypto/ec_signature_creator_nss.cc @@ -9,6 +9,8 @@ #include <secerr.h> #include <sechash.h> #if defined(OS_POSIX) +#include <stddef.h> +#include <stdint.h> #include <unistd.h> #endif @@ -32,7 +34,7 @@ SECStatus SignData(SECItem* result, } // Hash the input. - std::vector<uint8> hash_data(HASH_ResultLen(hash_type)); + std::vector<uint8_t> hash_data(HASH_ResultLen(hash_type)); SECStatus rv = HASH_HashBuf( hash_type, &hash_data[0], input->data, input->len); if (rv != SECSuccess) @@ -42,7 +44,7 @@ SECStatus SignData(SECItem* result, // Compute signature of hash. int signature_len = PK11_SignatureLen(key); - std::vector<uint8> signature_data(signature_len); + std::vector<uint8_t> signature_data(signature_len); SECItem sig = {siBuffer, &signature_data[0], static_cast<unsigned int>(signature_len)}; rv = PK11_Sign(key, &sig, &hash); @@ -62,9 +64,9 @@ ECSignatureCreatorImpl::ECSignatureCreatorImpl(ECPrivateKey* key) ECSignatureCreatorImpl::~ECSignatureCreatorImpl() {} -bool ECSignatureCreatorImpl::Sign(const uint8* data, +bool ECSignatureCreatorImpl::Sign(const uint8_t* data, int data_len, - std::vector<uint8>* signature) { + std::vector<uint8_t>* signature) { // Data to be signed SECItem secret; secret.type = siBuffer; @@ -92,12 +94,12 @@ bool ECSignatureCreatorImpl::Sign(const uint8* data, } bool ECSignatureCreatorImpl::DecodeSignature( - const std::vector<uint8>& der_sig, - std::vector<uint8>* out_raw_sig) { + const std::vector<uint8_t>& der_sig, + std::vector<uint8_t>* out_raw_sig) { SECItem der_sig_item; der_sig_item.type = siBuffer; der_sig_item.len = der_sig.size(); - der_sig_item.data = const_cast<uint8*>(&der_sig[0]); + der_sig_item.data = const_cast<uint8_t*>(&der_sig[0]); size_t signature_len = SECKEY_SignatureLen(key_->public_key()); if (signature_len == 0) diff --git a/crypto/ec_signature_creator_openssl.cc b/crypto/ec_signature_creator_openssl.cc index 30343a7..e9c39b7 100644 --- a/crypto/ec_signature_creator_openssl.cc +++ b/crypto/ec_signature_creator_openssl.cc @@ -9,6 +9,8 @@ #include <openssl/ecdsa.h> #include <openssl/evp.h> #include <openssl/sha.h> +#include <stddef.h> +#include <stdint.h> #include "base/logging.h" #include "crypto/ec_private_key.h" @@ -24,9 +26,9 @@ ECSignatureCreatorImpl::ECSignatureCreatorImpl(ECPrivateKey* key) ECSignatureCreatorImpl::~ECSignatureCreatorImpl() {} -bool ECSignatureCreatorImpl::Sign(const uint8* data, +bool ECSignatureCreatorImpl::Sign(const uint8_t* data, int data_len, - std::vector<uint8>* signature) { + std::vector<uint8_t>* signature) { OpenSSLErrStackTracer err_tracer(FROM_HERE); ScopedEVP_MD_CTX ctx(EVP_MD_CTX_create()); size_t sig_len = 0; @@ -48,8 +50,9 @@ bool ECSignatureCreatorImpl::Sign(const uint8* data, return true; } -bool ECSignatureCreatorImpl::DecodeSignature(const std::vector<uint8>& der_sig, - std::vector<uint8>* out_raw_sig) { +bool ECSignatureCreatorImpl::DecodeSignature( + const std::vector<uint8_t>& der_sig, + std::vector<uint8_t>* out_raw_sig) { OpenSSLErrStackTracer err_tracer(FROM_HERE); // Create ECDSA_SIG object from DER-encoded data. const unsigned char* der_data = &der_sig.front(); @@ -60,7 +63,7 @@ bool ECSignatureCreatorImpl::DecodeSignature(const std::vector<uint8>& der_sig, // The result is made of two 32-byte vectors. const size_t kMaxBytesPerBN = 32; - std::vector<uint8> result(2 * kMaxBytesPerBN); + std::vector<uint8_t> result(2 * kMaxBytesPerBN); if (!BN_bn2bin_padded(&result[0], kMaxBytesPerBN, ecdsa_sig->r) || !BN_bn2bin_padded(&result[kMaxBytesPerBN], kMaxBytesPerBN, diff --git a/crypto/ec_signature_creator_unittest.cc b/crypto/ec_signature_creator_unittest.cc index 2a40cfe..36c850a 100644 --- a/crypto/ec_signature_creator_unittest.cc +++ b/crypto/ec_signature_creator_unittest.cc @@ -4,6 +4,8 @@ #include "crypto/ec_signature_creator.h" +#include <stdint.h> + #include <string> #include <vector> @@ -21,10 +23,10 @@ TEST(ECSignatureCreatorTest, BasicTest) { crypto::ECPrivateKey::Create()); ASSERT_TRUE(key_original.get()); - std::vector<uint8> key_info; + std::vector<uint8_t> key_info; ASSERT_TRUE( key_original->ExportEncryptedPrivateKey(std::string(), 1000, &key_info)); - std::vector<uint8> pubkey_info; + std::vector<uint8_t> pubkey_info; ASSERT_TRUE(key_original->ExportPublicKey(&pubkey_info)); scoped_ptr<crypto::ECPrivateKey> key( @@ -38,12 +40,11 @@ TEST(ECSignatureCreatorTest, BasicTest) { ASSERT_TRUE(signer.get()); std::string data("Hello, World!"); - std::vector<uint8> signature; - ASSERT_TRUE(signer->Sign(reinterpret_cast<const uint8*>(data.c_str()), - data.size(), - &signature)); + std::vector<uint8_t> signature; + ASSERT_TRUE(signer->Sign(reinterpret_cast<const uint8_t*>(data.c_str()), + data.size(), &signature)); - std::vector<uint8> public_key_info; + std::vector<uint8_t> public_key_info; ASSERT_TRUE(key_original->ExportPublicKey(&public_key_info)); // This is the algorithm ID for ECDSA with SHA-256. Parameters are ABSENT. @@ -58,10 +59,8 @@ TEST(ECSignatureCreatorTest, BasicTest) { // component, the OID ecdsa-with-SHA224, ecdsa-with-SHA256, ecdsa-with- // SHA384, or ecdsa-with-SHA512. // See also RFC 5480, Appendix A. - const uint8 kECDSAWithSHA256AlgorithmID[] = { - 0x30, 0x0a, - 0x06, 0x08, - 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, + const uint8_t kECDSAWithSHA256AlgorithmID[] = { + 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, }; crypto::SignatureVerifier verifier; ASSERT_TRUE(verifier.VerifyInit( @@ -69,7 +68,7 @@ TEST(ECSignatureCreatorTest, BasicTest) { &signature[0], signature.size(), &public_key_info.front(), public_key_info.size())); - verifier.VerifyUpdate(reinterpret_cast<const uint8*>(data.c_str()), + verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(data.c_str()), data.size()); ASSERT_TRUE(verifier.VerifyFinal()); } diff --git a/crypto/encryptor.cc b/crypto/encryptor.cc index a673f81..7872774 100644 --- a/crypto/encryptor.cc +++ b/crypto/encryptor.cc @@ -4,6 +4,9 @@ #include "crypto/encryptor.h" +#include <stddef.h> +#include <stdint.h> + #include "base/logging.h" #include "base/sys_byteorder.h" @@ -21,8 +24,8 @@ Encryptor::Counter::~Counter() { } bool Encryptor::Counter::Increment() { - uint64 low_num = base::NetToHost64(counter_.components64[1]); - uint64 new_low_num = low_num + 1; + uint64_t low_num = base::NetToHost64(counter_.components64[1]); + uint64_t new_low_num = low_num + 1; counter_.components64[1] = base::HostToNet64(new_low_num); // If overflow occured then increment the most significant component. @@ -36,7 +39,7 @@ bool Encryptor::Counter::Increment() { } void Encryptor::Counter::Write(void* buf) { - uint8* buf_ptr = reinterpret_cast<uint8*>(buf); + uint8_t* buf_ptr = reinterpret_cast<uint8_t*>(buf); memcpy(buf_ptr, &counter_, sizeof(counter_)); } @@ -58,7 +61,7 @@ bool Encryptor::SetCounter(const base::StringPiece& counter) { } bool Encryptor::GenerateCounterMask(size_t plaintext_len, - uint8* mask, + uint8_t* mask, size_t* mask_len) { DCHECK_EQ(CTR, mode_); CHECK(mask); @@ -86,9 +89,9 @@ void Encryptor::MaskMessage(const void* plaintext, const void* mask, void* ciphertext) const { DCHECK_EQ(CTR, mode_); - const uint8* plaintext_ptr = reinterpret_cast<const uint8*>(plaintext); - const uint8* mask_ptr = reinterpret_cast<const uint8*>(mask); - uint8* ciphertext_ptr = reinterpret_cast<uint8*>(ciphertext); + const uint8_t* plaintext_ptr = reinterpret_cast<const uint8_t*>(plaintext); + const uint8_t* mask_ptr = reinterpret_cast<const uint8_t*>(mask); + uint8_t* ciphertext_ptr = reinterpret_cast<uint8_t*>(ciphertext); for (size_t i = 0; i < plaintext_len; ++i) ciphertext_ptr[i] = plaintext_ptr[i] ^ mask_ptr[i]; diff --git a/crypto/encryptor.h b/crypto/encryptor.h index 85ebaeb..e07eb32 100644 --- a/crypto/encryptor.h +++ b/crypto/encryptor.h @@ -5,9 +5,11 @@ #ifndef CRYPTO_ENCRYPTOR_H_ #define CRYPTO_ENCRYPTOR_H_ +#include <stddef.h> +#include <stdint.h> + #include <string> -#include "base/basictypes.h" #include "base/memory/scoped_ptr.h" #include "base/strings/string_piece.h" #include "build/build_config.h" @@ -47,8 +49,8 @@ class CRYPTO_EXPORT Encryptor { private: union { - uint32 components32[4]; - uint64 components64[2]; + uint32_t components32[4]; + uint64_t components64[2]; } counter_; }; @@ -99,7 +101,7 @@ class CRYPTO_EXPORT Encryptor { // // Returns false if this call failed. bool GenerateCounterMask(size_t plaintext_len, - uint8* mask, + uint8_t* mask, size_t* mask_len); // Mask the |plaintext| message using |mask|. The output will be written to diff --git a/crypto/encryptor_nss.cc b/crypto/encryptor_nss.cc index ca5d523..eca1377 100644 --- a/crypto/encryptor_nss.cc +++ b/crypto/encryptor_nss.cc @@ -5,6 +5,8 @@ #include "crypto/encryptor.h" #include <cryptohi.h> +#include <stddef.h> +#include <stdint.h> #include <vector> #include "base/logging.h" @@ -116,12 +118,12 @@ bool Encryptor::Crypt(PK11Context* context, CHECK_GT(output_len, input.size()); output->resize(output_len); - uint8* output_data = - reinterpret_cast<uint8*>(const_cast<char*>(output->data())); + uint8_t* output_data = + reinterpret_cast<uint8_t*>(const_cast<char*>(output->data())); int input_len = input.size(); - uint8* input_data = - reinterpret_cast<uint8*>(const_cast<char*>(input.data())); + uint8_t* input_data = + reinterpret_cast<uint8_t*>(const_cast<char*>(input.data())); int op_len; SECStatus rv = PK11_CipherOp(context, @@ -162,8 +164,8 @@ bool Encryptor::CryptCTR(PK11Context* context, AES_BLOCK_SIZE; CHECK_GE(output_len, input.size()); output->resize(output_len); - uint8* output_data = - reinterpret_cast<uint8*>(const_cast<char*>(output->data())); + uint8_t* output_data = + reinterpret_cast<uint8_t*>(const_cast<char*>(output->data())); size_t mask_len; bool ret = GenerateCounterMask(input.size(), output_data, &mask_len); @@ -192,9 +194,8 @@ bool Encryptor::CryptCTR(PK11Context* context, CHECK(!digest_len); // Use |output_data| to mask |input|. - MaskMessage( - reinterpret_cast<uint8*>(const_cast<char*>(input.data())), - input.length(), output_data, output_data); + MaskMessage(reinterpret_cast<uint8_t*>(const_cast<char*>(input.data())), + input.length(), output_data, output_data); output->resize(input.length()); return true; } diff --git a/crypto/encryptor_openssl.cc b/crypto/encryptor_openssl.cc index 4f0e511..238b2e0 100644 --- a/crypto/encryptor_openssl.cc +++ b/crypto/encryptor_openssl.cc @@ -6,6 +6,8 @@ #include <openssl/aes.h> #include <openssl/evp.h> +#include <stddef.h> +#include <stdint.h> #include "base/logging.h" #include "base/strings/string_util.h" @@ -103,21 +105,20 @@ bool Encryptor::Crypt(bool do_encrypt, DCHECK_EQ(EVP_CIPHER_key_length(cipher), key.length()); ScopedCipherCTX ctx; - if (!EVP_CipherInit_ex(ctx.get(), cipher, NULL, - reinterpret_cast<const uint8*>(key.data()), - reinterpret_cast<const uint8*>(iv_.data()), - do_encrypt)) + if (!EVP_CipherInit_ex( + ctx.get(), cipher, NULL, reinterpret_cast<const uint8_t*>(key.data()), + reinterpret_cast<const uint8_t*>(iv_.data()), do_encrypt)) return false; // When encrypting, add another block size of space to allow for any padding. const size_t output_size = input.size() + (do_encrypt ? iv_.size() : 0); CHECK_GT(output_size, 0u); CHECK_GT(output_size + 1, input.size()); - uint8* out_ptr = - reinterpret_cast<uint8*>(base::WriteInto(&result, output_size + 1)); + uint8_t* out_ptr = + reinterpret_cast<uint8_t*>(base::WriteInto(&result, output_size + 1)); int out_len; if (!EVP_CipherUpdate(ctx.get(), out_ptr, &out_len, - reinterpret_cast<const uint8*>(input.data()), + reinterpret_cast<const uint8_t*>(input.data()), input.length())) return false; @@ -144,7 +145,7 @@ bool Encryptor::CryptCTR(bool do_encrypt, } AES_KEY aes_key; - if (AES_set_encrypt_key(reinterpret_cast<const uint8*>(key_->key().data()), + if (AES_set_encrypt_key(reinterpret_cast<const uint8_t*>(key_->key().data()), key_->key().size() * 8, &aes_key) != 0) { return false; } @@ -154,8 +155,8 @@ bool Encryptor::CryptCTR(bool do_encrypt, CHECK_GT(out_size + 1, input.size()); std::string result; - uint8* out_ptr = - reinterpret_cast<uint8*>(base::WriteInto(&result, out_size + 1)); + uint8_t* out_ptr = + reinterpret_cast<uint8_t*>(base::WriteInto(&result, out_size + 1)); uint8_t ivec[AES_BLOCK_SIZE] = { 0 }; uint8_t ecount_buf[AES_BLOCK_SIZE] = { 0 }; @@ -163,7 +164,7 @@ bool Encryptor::CryptCTR(bool do_encrypt, counter_->Write(ivec); - AES_ctr128_encrypt(reinterpret_cast<const uint8*>(input.data()), out_ptr, + AES_ctr128_encrypt(reinterpret_cast<const uint8_t*>(input.data()), out_ptr, input.size(), &aes_key, ivec, ecount_buf, &block_offset); // AES_ctr128_encrypt() updates |ivec|. Update the |counter_| here. diff --git a/crypto/encryptor_unittest.cc b/crypto/encryptor_unittest.cc index 79fe2cc..93355f8 100644 --- a/crypto/encryptor_unittest.cc +++ b/crypto/encryptor_unittest.cc @@ -4,8 +4,11 @@ #include "crypto/encryptor.h" +#include <stddef.h> + #include <string> +#include "base/macros.h" #include "base/memory/scoped_ptr.h" #include "base/strings/string_number_conversions.h" #include "crypto/symmetric_key.h" diff --git a/crypto/ghash.cc b/crypto/ghash.cc index 1acd474..fcd513e 100644 --- a/crypto/ghash.cc +++ b/crypto/ghash.cc @@ -4,6 +4,9 @@ #include "crypto/ghash.h" +#include <stddef.h> +#include <stdint.h> + #include <algorithm> #include "base/logging.h" @@ -27,14 +30,14 @@ namespace crypto { namespace { // Get64 reads a 64-bit, big-endian number from |bytes|. -uint64 Get64(const uint8 bytes[8]) { - uint64 t; +uint64_t Get64(const uint8_t bytes[8]) { + uint64_t t; memcpy(&t, bytes, sizeof(t)); return base::NetToHost64(t); } // Put64 writes |x| to |bytes| as a 64-bit, big-endian number. -void Put64(uint8 bytes[8], uint64 x) { +void Put64(uint8_t bytes[8], uint64_t x) { x = base::HostToNet64(x); memcpy(bytes, &x, sizeof(x)); } @@ -48,7 +51,7 @@ int Reverse(int i) { } // namespace -GaloisHash::GaloisHash(const uint8 key[16]) { +GaloisHash::GaloisHash(const uint8_t key[16]) { Reset(); // We precompute 16 multiples of |key|. However, when we do lookups into this @@ -76,13 +79,13 @@ void GaloisHash::Reset() { y_.hi = 0; } -void GaloisHash::UpdateAdditional(const uint8* data, size_t length) { +void GaloisHash::UpdateAdditional(const uint8_t* data, size_t length) { DCHECK_EQ(state_, kHashingAdditionalData); additional_bytes_ += length; Update(data, length); } -void GaloisHash::UpdateCiphertext(const uint8* data, size_t length) { +void GaloisHash::UpdateCiphertext(const uint8_t* data, size_t length) { if (state_ == kHashingAdditionalData) { // If there's any remaining additional data it's zero padded to the next // full block. @@ -118,9 +121,9 @@ void GaloisHash::Finish(void* output, size_t len) { y_.hi ^= ciphertext_bytes_*8; MulAfterPrecomputation(product_table_, &y_); - uint8 *result, result_tmp[16]; + uint8_t *result, result_tmp[16]; if (len >= 16) { - result = reinterpret_cast<uint8*>(output); + result = reinterpret_cast<uint8_t*>(output); } else { result = result_tmp; } @@ -177,7 +180,7 @@ void GaloisHash::MulAfterPrecomputation(const FieldElement* table, // characteristic 2 fields, repeated doublings are exceptionally cheap and // it's not worth spending more precomputation time to eliminate them. for (unsigned i = 0; i < 2; i++) { - uint64 word; + uint64_t word; if (i == 0) { word = x->hi; } else { @@ -205,9 +208,9 @@ void GaloisHash::MulAfterPrecomputation(const FieldElement* table, // least-significant 8 bits, save for the term at x^128. Therefore we can // precompute the value to be added to the field element for each of the 16 bit // patterns at 2**128 and the values fit within 12 bits. -static const uint16 kReductionTable[16] = { - 0x0000, 0x1c20, 0x3840, 0x2460, 0x7080, 0x6ca0, 0x48c0, 0x54e0, - 0xe100, 0xfd20, 0xd940, 0xc560, 0x9180, 0x8da0, 0xa9c0, 0xb5e0, +static const uint16_t kReductionTable[16] = { + 0x0000, 0x1c20, 0x3840, 0x2460, 0x7080, 0x6ca0, 0x48c0, 0x54e0, + 0xe100, 0xfd20, 0xd940, 0xc560, 0x9180, 0x8da0, 0xa9c0, 0xb5e0, }; // static @@ -216,10 +219,10 @@ void GaloisHash::Mul16(FieldElement* x) { x->hi >>= 4; x->hi |= x->low << 60; x->low >>= 4; - x->low ^= static_cast<uint64>(kReductionTable[msw]) << 48; + x->low ^= static_cast<uint64_t>(kReductionTable[msw]) << 48; } -void GaloisHash::UpdateBlocks(const uint8* bytes, size_t num_blocks) { +void GaloisHash::UpdateBlocks(const uint8_t* bytes, size_t num_blocks) { for (size_t i = 0; i < num_blocks; i++) { y_.low ^= Get64(bytes); bytes += 8; @@ -229,7 +232,7 @@ void GaloisHash::UpdateBlocks(const uint8* bytes, size_t num_blocks) { } } -void GaloisHash::Update(const uint8* data, size_t length) { +void GaloisHash::Update(const uint8_t* data, size_t length) { if (buf_used_ > 0) { const size_t n = std::min(length, sizeof(buf_) - buf_used_); memcpy(&buf_[buf_used_], data, n); diff --git a/crypto/ghash.h b/crypto/ghash.h index 53f6b51..b123dfe 100644 --- a/crypto/ghash.h +++ b/crypto/ghash.h @@ -2,7 +2,9 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "base/basictypes.h" +#include <stddef.h> +#include <stdint.h> + #include "crypto/crypto_export.h" namespace crypto { @@ -27,7 +29,7 @@ namespace crypto { // the implementation of AES that is used. class CRYPTO_EXPORT GaloisHash { public: - explicit GaloisHash(const uint8 key[16]); + explicit GaloisHash(const uint8_t key[16]); // Reset prepares to digest a fresh message with the same key. This is more // efficient than creating a fresh object. @@ -36,10 +38,10 @@ class CRYPTO_EXPORT GaloisHash { // UpdateAdditional hashes in `additional' data. This is data that is not // encrypted, but is covered by the authenticator. All additional data must // be written before any ciphertext is written. - void UpdateAdditional(const uint8* data, size_t length); + void UpdateAdditional(const uint8_t* data, size_t length); // UpdateCiphertext hashes in ciphertext to be authenticated. - void UpdateCiphertext(const uint8* data, size_t length); + void UpdateCiphertext(const uint8_t* data, size_t length); // Finish completes the hash computation and writes at most |len| bytes of // the result to |output|. @@ -53,7 +55,7 @@ class CRYPTO_EXPORT GaloisHash { }; struct FieldElement { - uint64 low, hi; + uint64_t low, hi; }; // Add returns |x|+|y|. @@ -68,17 +70,17 @@ class CRYPTO_EXPORT GaloisHash { static void Mul16(FieldElement* x); // UpdateBlocks processes |num_blocks| 16-bytes blocks from |bytes|. - void UpdateBlocks(const uint8* bytes, size_t num_blocks); + void UpdateBlocks(const uint8_t* bytes, size_t num_blocks); // Update processes |length| bytes from |bytes| and calls UpdateBlocks on as // much data as possible. It uses |buf_| to buffer any remaining data and // always consumes all of |bytes|. - void Update(const uint8* bytes, size_t length); + void Update(const uint8_t* bytes, size_t length); FieldElement y_; State state_; size_t additional_bytes_; size_t ciphertext_bytes_; - uint8 buf_[16]; + uint8_t buf_[16]; size_t buf_used_; FieldElement product_table_[16]; }; diff --git a/crypto/ghash_unittest.cc b/crypto/ghash_unittest.cc index 5dd88ed..01f9cf4 100644 --- a/crypto/ghash_unittest.cc +++ b/crypto/ghash_unittest.cc @@ -2,10 +2,14 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include <algorithm> - #include "crypto/ghash.h" +#include <stddef.h> +#include <stdint.h> + +#include <algorithm> + +#include "base/macros.h" #include "testing/gtest/include/gtest/gtest.h" namespace crypto { @@ -15,45 +19,42 @@ namespace { // Test vectors are taken from Appendix B of // http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/gcm/gcm-revised-spec.pdf -static const uint8 kKey1[16] = { - 0x66, 0xe9, 0x4b, 0xd4, 0xef, 0x8a, 0x2c, 0x3b, - 0x88, 0x4c, 0xfa, 0x59, 0xca, 0x34, 0x2b, 0x2e, +static const uint8_t kKey1[16] = { + 0x66, 0xe9, 0x4b, 0xd4, 0xef, 0x8a, 0x2c, 0x3b, + 0x88, 0x4c, 0xfa, 0x59, 0xca, 0x34, 0x2b, 0x2e, }; -static const uint8 kCiphertext2[] = { - 0x03, 0x88, 0xda, 0xce, 0x60, 0xb6, 0xa3, 0x92, - 0xf3, 0x28, 0xc2, 0xb9, 0x71, 0xb2, 0xfe, 0x78, +static const uint8_t kCiphertext2[] = { + 0x03, 0x88, 0xda, 0xce, 0x60, 0xb6, 0xa3, 0x92, + 0xf3, 0x28, 0xc2, 0xb9, 0x71, 0xb2, 0xfe, 0x78, }; -static const uint8 kKey3[16] = { - 0xb8, 0x3b, 0x53, 0x37, 0x08, 0xbf, 0x53, 0x5d, - 0x0a, 0xa6, 0xe5, 0x29, 0x80, 0xd5, 0x3b, 0x78, +static const uint8_t kKey3[16] = { + 0xb8, 0x3b, 0x53, 0x37, 0x08, 0xbf, 0x53, 0x5d, + 0x0a, 0xa6, 0xe5, 0x29, 0x80, 0xd5, 0x3b, 0x78, }; -static const uint8 kCiphertext3[] = { - 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24, - 0x4b, 0x72, 0x21, 0xb7, 0x84, 0xd0, 0xd4, 0x9c, - 0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, 0xa4, 0xe0, - 0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e, - 0x21, 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c, - 0x7d, 0x8f, 0x6a, 0x5a, 0xac, 0x84, 0xaa, 0x05, - 0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, 0x97, - 0x3d, 0x58, 0xe0, 0x91, 0x47, 0x3f, 0x59, 0x85, +static const uint8_t kCiphertext3[] = { + 0x42, 0x83, 0x1e, 0xc2, 0x21, 0x77, 0x74, 0x24, 0x4b, 0x72, 0x21, + 0xb7, 0x84, 0xd0, 0xd4, 0x9c, 0xe3, 0xaa, 0x21, 0x2f, 0x2c, 0x02, + 0xa4, 0xe0, 0x35, 0xc1, 0x7e, 0x23, 0x29, 0xac, 0xa1, 0x2e, 0x21, + 0xd5, 0x14, 0xb2, 0x54, 0x66, 0x93, 0x1c, 0x7d, 0x8f, 0x6a, 0x5a, + 0xac, 0x84, 0xaa, 0x05, 0x1b, 0xa3, 0x0b, 0x39, 0x6a, 0x0a, 0xac, + 0x97, 0x3d, 0x58, 0xe0, 0x91, 0x47, 0x3f, 0x59, 0x85, }; -static const uint8 kAdditional4[] = { - 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef, - 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef, - 0xab, 0xad, 0xda, 0xd2, +static const uint8_t kAdditional4[] = { + 0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef, 0xfe, 0xed, + 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef, 0xab, 0xad, 0xda, 0xd2, }; struct TestCase { - const uint8* key; - const uint8* additional; + const uint8_t* key; + const uint8_t* additional; unsigned additional_length; - const uint8* ciphertext; + const uint8_t* ciphertext; unsigned ciphertext_length; - const uint8 expected[16]; + const uint8_t expected[16]; }; static const TestCase kTestCases[] = { @@ -104,7 +105,7 @@ static const TestCase kTestCases[] = { }; TEST(GaloisHash, TestCases) { - uint8 out[16]; + uint8_t out[16]; for (size_t i = 0; i < arraysize(kTestCases); ++i) { const TestCase& test = kTestCases[i]; @@ -120,7 +121,7 @@ TEST(GaloisHash, TestCases) { } TEST(GaloisHash, VaryLengths) { - uint8 out[16]; + uint8_t out[16]; for (size_t chunk_size = 1; chunk_size < 16; chunk_size++) { for (size_t i = 0; i < arraysize(kTestCases); ++i) { diff --git a/crypto/hkdf.cc b/crypto/hkdf.cc index 82aae24..67c3921 100644 --- a/crypto/hkdf.cc +++ b/crypto/hkdf.cc @@ -4,6 +4,9 @@ #include "crypto/hkdf.h" +#include <stddef.h> +#include <stdint.h> + #include "base/logging.h" #include "base/memory/scoped_ptr.h" #include "crypto/hmac.h" @@ -34,7 +37,7 @@ HKDF::HKDF(const base::StringPiece& secret, DCHECK(result); // |prk| is a pseudorandom key (of kSHA256HashLength octets). - uint8 prk[kSHA256HashLength]; + uint8_t prk[kSHA256HashLength]; DCHECK_EQ(sizeof(prk), prk_hmac.DigestLength()); result = prk_hmac.Sign(secret, prk, sizeof(prk)); DCHECK(result); @@ -53,7 +56,7 @@ HKDF::HKDF(const base::StringPiece& secret, base::StringPiece previous; scoped_ptr<char[]> buf(new char[kSHA256HashLength + info.size() + 1]); - uint8 digest[kSHA256HashLength]; + uint8_t digest[kSHA256HashLength]; HMAC hmac(HMAC::SHA256); result = hmac.Init(prk, sizeof(prk)); diff --git a/crypto/hkdf.h b/crypto/hkdf.h index e91bccf..6b7d00d 100644 --- a/crypto/hkdf.h +++ b/crypto/hkdf.h @@ -5,9 +5,11 @@ #ifndef CRYPTO_HKDF_H_ #define CRYPTO_HKDF_H_ +#include <stddef.h> +#include <stdint.h> + #include <vector> -#include "base/basictypes.h" #include "base/strings/string_piece.h" #include "crypto/crypto_export.h" @@ -57,7 +59,7 @@ class CRYPTO_EXPORT HKDF { } private: - std::vector<uint8> output_; + std::vector<uint8_t> output_; base::StringPiece client_write_key_; base::StringPiece server_write_key_; diff --git a/crypto/hkdf_unittest.cc b/crypto/hkdf_unittest.cc index bcb19c5..0412703 100644 --- a/crypto/hkdf_unittest.cc +++ b/crypto/hkdf_unittest.cc @@ -4,8 +4,12 @@ #include "crypto/hkdf.h" +#include <stddef.h> +#include <stdint.h> + #include <string> +#include "base/macros.h" #include "base/strings/string_number_conversions.h" #include "testing/gtest/include/gtest/gtest.h" @@ -56,7 +60,7 @@ TEST(HKDFTest, HKDF) { const HKDFTest& test(kHKDFTests[i]); SCOPED_TRACE(i); - std::vector<uint8> data; + std::vector<uint8_t> data; ASSERT_TRUE(base::HexStringToBytes(test.key_hex, &data)); const std::string key(reinterpret_cast<char*>(&data[0]), data.size()); diff --git a/crypto/hmac.cc b/crypto/hmac.cc index c9a2b74..e9869b4 100644 --- a/crypto/hmac.cc +++ b/crypto/hmac.cc @@ -4,6 +4,8 @@ #include "crypto/hmac.h" +#include <stddef.h> + #include <algorithm> #include "base/logging.h" diff --git a/crypto/hmac.h b/crypto/hmac.h index c7b22fa..ccdab30 100644 --- a/crypto/hmac.h +++ b/crypto/hmac.h @@ -8,8 +8,10 @@ #ifndef CRYPTO_HMAC_H_ #define CRYPTO_HMAC_H_ -#include "base/basictypes.h" +#include <stddef.h> + #include "base/compiler_specific.h" +#include "base/macros.h" #include "base/memory/scoped_ptr.h" #include "base/strings/string_piece.h" #include "crypto/crypto_export.h" diff --git a/crypto/hmac_nss.cc b/crypto/hmac_nss.cc index e14282c..9d759b5d 100644 --- a/crypto/hmac_nss.cc +++ b/crypto/hmac_nss.cc @@ -6,6 +6,7 @@ #include <nss.h> #include <pk11pub.h> +#include <stddef.h> #include "base/logging.h" #include "base/memory/scoped_ptr.h" diff --git a/crypto/hmac_openssl.cc b/crypto/hmac_openssl.cc index 8f043f1..8c8c11a 100644 --- a/crypto/hmac_openssl.cc +++ b/crypto/hmac_openssl.cc @@ -5,6 +5,7 @@ #include "crypto/hmac.h" #include <openssl/hmac.h> +#include <stddef.h> #include <algorithm> #include <vector> diff --git a/crypto/hmac_unittest.cc b/crypto/hmac_unittest.cc index 91eccd6..f8dbd5a 100644 --- a/crypto/hmac_unittest.cc +++ b/crypto/hmac_unittest.cc @@ -2,8 +2,11 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +#include <stddef.h> + #include <string> +#include "base/macros.h" #include "crypto/hmac.h" #include "testing/gtest/include/gtest/gtest.h" diff --git a/crypto/hmac_win.cc b/crypto/hmac_win.cc index 99b3a60..ab29081 100644 --- a/crypto/hmac_win.cc +++ b/crypto/hmac_win.cc @@ -5,6 +5,7 @@ #include "crypto/hmac.h" #include <windows.h> +#include <stddef.h> #include <algorithm> #include <vector> diff --git a/crypto/mac_security_services_lock.cc b/crypto/mac_security_services_lock.cc index af66918..902a871 100644 --- a/crypto/mac_security_services_lock.cc +++ b/crypto/mac_security_services_lock.cc @@ -4,6 +4,7 @@ #include "crypto/mac_security_services_lock.h" +#include "base/macros.h" #include "base/memory/singleton.h" #include "base/synchronization/lock.h" diff --git a/crypto/mock_apple_keychain.cc b/crypto/mock_apple_keychain.cc index a1faa65..dd3d7c5 100644 --- a/crypto/mock_apple_keychain.cc +++ b/crypto/mock_apple_keychain.cc @@ -3,6 +3,7 @@ // found in the LICENSE file. #include "base/logging.h" +#include "base/macros.h" #include "base/metrics/histogram.h" #include "base/time/time.h" #include "crypto/mock_apple_keychain.h" diff --git a/crypto/mock_apple_keychain.h b/crypto/mock_apple_keychain.h index f73d3a6..f36e982 100644 --- a/crypto/mock_apple_keychain.h +++ b/crypto/mock_apple_keychain.h @@ -5,6 +5,7 @@ #ifndef CRYPTO_MOCK_KEYCHAIN_MAC_H_ #define CRYPTO_MOCK_KEYCHAIN_MAC_H_ +#include <stddef.h> #include <stdint.h> #include <map> diff --git a/crypto/mock_apple_keychain_mac.cc b/crypto/mock_apple_keychain_mac.cc index 5f33e5b..e4bc30c 100644 --- a/crypto/mock_apple_keychain_mac.cc +++ b/crypto/mock_apple_keychain_mac.cc @@ -2,7 +2,10 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +#include <stddef.h> + #include "base/logging.h" +#include "base/macros.h" #include "base/time/time.h" #include "crypto/mock_apple_keychain.h" diff --git a/crypto/nss_key_util.cc b/crypto/nss_key_util.cc index 7a5d6b4..f48cb0f 100644 --- a/crypto/nss_key_util.cc +++ b/crypto/nss_key_util.cc @@ -7,6 +7,7 @@ #include <cryptohi.h> #include <keyhi.h> #include <pk11pub.h> +#include <stdint.h> #include "base/logging.h" #include "crypto/nss_util.h" diff --git a/crypto/nss_key_util_unittest.cc b/crypto/nss_key_util_unittest.cc index ff4d55a..99b52a9 100644 --- a/crypto/nss_key_util_unittest.cc +++ b/crypto/nss_key_util_unittest.cc @@ -6,6 +6,7 @@ #include <keyhi.h> #include <pk11pub.h> +#include <stdint.h> #include <vector> diff --git a/crypto/nss_util.h b/crypto/nss_util.h index 06c1e5d..71e5a67 100644 --- a/crypto/nss_util.h +++ b/crypto/nss_util.h @@ -5,10 +5,12 @@ #ifndef CRYPTO_NSS_UTIL_H_ #define CRYPTO_NSS_UTIL_H_ +#include <stdint.h> + #include <string> -#include "base/basictypes.h" #include "base/callback.h" #include "base/compiler_specific.h" +#include "base/macros.h" #include "crypto/crypto_export.h" namespace base { @@ -72,12 +74,12 @@ CRYPTO_EXPORT void InitializeTPMTokenAndSystemSlot( #endif // Convert a NSS PRTime value into a base::Time object. -// We use a int64 instead of PRTime here to avoid depending on NSPR headers. -CRYPTO_EXPORT base::Time PRTimeToBaseTime(int64 prtime); +// We use a int64_t instead of PRTime here to avoid depending on NSPR headers. +CRYPTO_EXPORT base::Time PRTimeToBaseTime(int64_t prtime); // Convert a base::Time object into a PRTime value. -// We use a int64 instead of PRTime here to avoid depending on NSPR headers. -CRYPTO_EXPORT int64 BaseTimeToPRTime(base::Time time); +// We use a int64_t instead of PRTime here to avoid depending on NSPR headers. +CRYPTO_EXPORT int64_t BaseTimeToPRTime(base::Time time); #if defined(USE_NSS_CERTS) // NSS has a bug which can cause a deadlock or stall in some cases when writing diff --git a/crypto/nss_util_internal.h b/crypto/nss_util_internal.h index 17d6187..0982a6e8 100644 --- a/crypto/nss_util_internal.h +++ b/crypto/nss_util_internal.h @@ -9,6 +9,7 @@ #include "base/callback.h" #include "base/compiler_specific.h" +#include "base/macros.h" #include "crypto/crypto_export.h" #include "crypto/scoped_nss_types.h" diff --git a/crypto/openssl_util.cc b/crypto/openssl_util.cc index f5b20c9..48ec3e2 100644 --- a/crypto/openssl_util.cc +++ b/crypto/openssl_util.cc @@ -7,8 +7,11 @@ #include <openssl/err.h> #include <openssl/ssl.h> #include <openssl/cpu.h> +#include <stddef.h> +#include <stdint.h> #include "base/logging.h" +#include "base/macros.h" #include "base/memory/singleton.h" #include "base/strings/string_piece.h" #include "build/build_config.h" diff --git a/crypto/openssl_util.h b/crypto/openssl_util.h index 2743883..78fa66e 100644 --- a/crypto/openssl_util.h +++ b/crypto/openssl_util.h @@ -5,8 +5,10 @@ #ifndef CRYPTO_OPENSSL_UTIL_H_ #define CRYPTO_OPENSSL_UTIL_H_ -#include "base/basictypes.h" +#include <stddef.h> + #include "base/location.h" +#include "base/macros.h" #include "crypto/crypto_export.h" namespace crypto { diff --git a/crypto/p224.cc b/crypto/p224.cc index a86163f..685a335 100644 --- a/crypto/p224.cc +++ b/crypto/p224.cc @@ -9,6 +9,8 @@ #include "crypto/p224.h" +#include <stddef.h> +#include <stdint.h> #include <string.h> #include "base/sys_byteorder.h" @@ -23,7 +25,7 @@ using base::NetToHost32; // The field that we're dealing with is ℤ/pℤ where p = 2**224 - 2**96 + 1. // // Field elements are represented by a FieldElement, which is a typedef to an -// array of 8 uint32's. The value of a FieldElement, a, is: +// array of 8 uint32_t's. The value of a FieldElement, a, is: // a[0] + 2**28·a[1] + 2**56·a[1] + ... + 2**196·a[7] // // Using 28-bit limbs means that there's only 4 bits of headroom, which is less @@ -41,12 +43,12 @@ const FieldElement kP = { void Contract(FieldElement* inout); // IsZero returns 0xffffffff if a == 0 mod p and 0 otherwise. -uint32 IsZero(const FieldElement& a) { +uint32_t IsZero(const FieldElement& a) { FieldElement minimal; memcpy(&minimal, &a, sizeof(minimal)); Contract(&minimal); - uint32 is_zero = 0, is_p = 0; + uint32_t is_zero = 0, is_p = 0; for (unsigned i = 0; i < 8; i++) { is_zero |= minimal[i]; is_p |= minimal[i] - kP[i]; @@ -68,7 +70,7 @@ uint32 IsZero(const FieldElement& a) { // For is_zero and is_p, the LSB is 0 iff all the bits are zero. is_zero &= is_p & 1; is_zero = (~is_zero) << 31; - is_zero = static_cast<int32>(is_zero) >> 31; + is_zero = static_cast<int32_t>(is_zero) >> 31; return is_zero; } @@ -81,9 +83,9 @@ void Add(FieldElement* out, const FieldElement& a, const FieldElement& b) { } } -static const uint32 kTwo31p3 = (1u<<31) + (1u<<3); -static const uint32 kTwo31m3 = (1u<<31) - (1u<<3); -static const uint32 kTwo31m15m3 = (1u<<31) - (1u<<15) - (1u<<3); +static const uint32_t kTwo31p3 = (1u << 31) + (1u << 3); +static const uint32_t kTwo31m3 = (1u << 31) - (1u << 3); +static const uint32_t kTwo31m15m3 = (1u << 31) - (1u << 15) - (1u << 3); // kZero31ModP is 0 mod p where bit 31 is set in all limbs so that we can // subtract smaller amounts without underflow. See the section "Subtraction" in // [1] for why. @@ -103,22 +105,22 @@ void Subtract(FieldElement* out, const FieldElement& a, const FieldElement& b) { } } -static const uint64 kTwo63p35 = (1ull<<63) + (1ull<<35); -static const uint64 kTwo63m35 = (1ull<<63) - (1ull<<35); -static const uint64 kTwo63m35m19 = (1ull<<63) - (1ull<<35) - (1ull<<19); +static const uint64_t kTwo63p35 = (1ull << 63) + (1ull << 35); +static const uint64_t kTwo63m35 = (1ull << 63) - (1ull << 35); +static const uint64_t kTwo63m35m19 = (1ull << 63) - (1ull << 35) - (1ull << 19); // kZero63ModP is 0 mod p where bit 63 is set in all limbs. See the section // "Subtraction" in [1] for why. -static const uint64 kZero63ModP[8] = { - kTwo63p35, kTwo63m35, kTwo63m35, kTwo63m35, - kTwo63m35m19, kTwo63m35, kTwo63m35, kTwo63m35, +static const uint64_t kZero63ModP[8] = { + kTwo63p35, kTwo63m35, kTwo63m35, kTwo63m35, + kTwo63m35m19, kTwo63m35, kTwo63m35, kTwo63m35, }; -static const uint32 kBottom28Bits = 0xfffffff; +static const uint32_t kBottom28Bits = 0xfffffff; // LargeFieldElement also represents an element of the field. The limbs are // still spaced 28-bits apart and in little-endian order. So the limbs are at // 0, 28, 56, ..., 392 bits, each 64-bits wide. -typedef uint64 LargeFieldElement[15]; +typedef uint64_t LargeFieldElement[15]; // ReduceLarge converts a LargeFieldElement to a FieldElement. // @@ -144,21 +146,21 @@ void ReduceLarge(FieldElement* out, LargeFieldElement* inptr) { // 32-bit operations. for (int i = 1; i < 8; i++) { in[i+1] += in[i] >> 28; - (*out)[i] = static_cast<uint32>(in[i] & kBottom28Bits); + (*out)[i] = static_cast<uint32_t>(in[i] & kBottom28Bits); } // Eliminate the term at 2*224 that we introduced while keeping the same // value mod p. in[0] -= in[8]; // reflection off the "+1" term of p. - (*out)[3] += static_cast<uint32>(in[8] & 0xffff) << 12; // "-2**96" term - (*out)[4] += static_cast<uint32>(in[8] >> 16); // rest of "-2**96" term + (*out)[3] += static_cast<uint32_t>(in[8] & 0xffff) << 12; // "-2**96" term + (*out)[4] += static_cast<uint32_t>(in[8] >> 16); // rest of "-2**96" term // in[0] < 2**64 // out[3] < 2**29 // out[4] < 2**29 // out[1,2,5..7] < 2**28 - (*out)[0] = static_cast<uint32>(in[0] & kBottom28Bits); - (*out)[1] += static_cast<uint32>((in[0] >> 28) & kBottom28Bits); - (*out)[2] += static_cast<uint32>(in[0] >> 56); + (*out)[0] = static_cast<uint32_t>(in[0] & kBottom28Bits); + (*out)[1] += static_cast<uint32_t>((in[0] >> 28) & kBottom28Bits); + (*out)[2] += static_cast<uint32_t>(in[0] >> 56); // out[0] < 2**28 // out[1..4] < 2**29 // out[5..7] < 2**28 @@ -174,7 +176,7 @@ void Mul(FieldElement* out, const FieldElement& a, const FieldElement& b) { for (int i = 0; i < 8; i++) { for (int j = 0; j < 8; j++) { - tmp[i+j] += static_cast<uint64>(a[i]) * static_cast<uint64>(b[j]); + tmp[i + j] += static_cast<uint64_t>(a[i]) * static_cast<uint64_t>(b[j]); } } @@ -191,7 +193,7 @@ void Square(FieldElement* out, const FieldElement& a) { for (int i = 0; i < 8; i++) { for (int j = 0; j <= i; j++) { - uint64 r = static_cast<uint64>(a[i]) * static_cast<uint64>(a[j]); + uint64_t r = static_cast<uint64_t>(a[i]) * static_cast<uint64_t>(a[j]); if (i == j) { tmp[i+j] += r; } else { @@ -214,16 +216,16 @@ void Reduce(FieldElement* in_out) { a[i+1] += a[i] >> 28; a[i] &= kBottom28Bits; } - uint32 top = a[7] >> 28; + uint32_t top = a[7] >> 28; a[7] &= kBottom28Bits; // top < 2**4 // Constant-time: mask = (top != 0) ? 0xffffffff : 0 - uint32 mask = top; + uint32_t mask = top; mask |= mask >> 2; mask |= mask >> 1; mask <<= 31; - mask = static_cast<uint32>(static_cast<int32>(mask) >> 31); + mask = static_cast<uint32_t>(static_cast<int32_t>(mask) >> 31); // Eliminate top while maintaining the same value mod p. a[0] -= top; @@ -300,7 +302,7 @@ void Contract(FieldElement* inout) { out[i+1] += out[i] >> 28; out[i] &= kBottom28Bits; } - uint32 top = out[7] >> 28; + uint32_t top = out[7] >> 28; out[7] &= kBottom28Bits; // Eliminate top while maintaining the same value mod p. @@ -311,7 +313,7 @@ void Contract(FieldElement* inout) { // out[0] negative then we know that out[3] is sufficiently positive // because we just added to it. for (int i = 0; i < 3; i++) { - uint32 mask = static_cast<uint32>(static_cast<int32>(out[i]) >> 31); + uint32_t mask = static_cast<uint32_t>(static_cast<int32_t>(out[i]) >> 31); out[i] += (1 << 28) & mask; out[i+1] -= 1 & mask; } @@ -344,7 +346,7 @@ void Contract(FieldElement* inout) { // As before, if we made out[0] negative then we know that out[3] is // sufficiently positive. for (int i = 0; i < 3; i++) { - uint32 mask = static_cast<uint32>(static_cast<int32>(out[i]) >> 31); + uint32_t mask = static_cast<uint32_t>(static_cast<int32_t>(out[i]) >> 31); out[i] += (1 << 28) & mask; out[i+1] -= 1 & mask; } @@ -356,7 +358,7 @@ void Contract(FieldElement* inout) { // equal to bottom28Bits if the whole value is >= p. If top_4_all_ones // ends up with any zero bits in the bottom 28 bits, then this wasn't // true. - uint32 top_4_all_ones = 0xffffffffu; + uint32_t top_4_all_ones = 0xffffffffu; for (int i = 4; i < 8; i++) { top_4_all_ones &= out[i]; } @@ -368,37 +370,39 @@ void Contract(FieldElement* inout) { top_4_all_ones &= top_4_all_ones >> 2; top_4_all_ones &= top_4_all_ones >> 1; top_4_all_ones = - static_cast<uint32>(static_cast<int32>(top_4_all_ones << 31) >> 31); + static_cast<uint32_t>(static_cast<int32_t>(top_4_all_ones << 31) >> 31); // Now we test whether the bottom three limbs are non-zero. - uint32 bottom_3_non_zero = out[0] | out[1] | out[2]; + uint32_t bottom_3_non_zero = out[0] | out[1] | out[2]; bottom_3_non_zero |= bottom_3_non_zero >> 16; bottom_3_non_zero |= bottom_3_non_zero >> 8; bottom_3_non_zero |= bottom_3_non_zero >> 4; bottom_3_non_zero |= bottom_3_non_zero >> 2; bottom_3_non_zero |= bottom_3_non_zero >> 1; bottom_3_non_zero = - static_cast<uint32>(static_cast<int32>(bottom_3_non_zero) >> 31); + static_cast<uint32_t>(static_cast<int32_t>(bottom_3_non_zero) >> 31); // Everything depends on the value of out[3]. // If it's > 0xffff000 and top_4_all_ones != 0 then the whole value is >= p // If it's = 0xffff000 and top_4_all_ones != 0 and bottom_3_non_zero != 0, // then the whole value is >= p // If it's < 0xffff000, then the whole value is < p - uint32 n = out[3] - 0xffff000; - uint32 out_3_equal = n; + uint32_t n = out[3] - 0xffff000; + uint32_t out_3_equal = n; out_3_equal |= out_3_equal >> 16; out_3_equal |= out_3_equal >> 8; out_3_equal |= out_3_equal >> 4; out_3_equal |= out_3_equal >> 2; out_3_equal |= out_3_equal >> 1; out_3_equal = - ~static_cast<uint32>(static_cast<int32>(out_3_equal << 31) >> 31); + ~static_cast<uint32_t>(static_cast<int32_t>(out_3_equal << 31) >> 31); // If out[3] > 0xffff000 then n's MSB will be zero. - uint32 out_3_gt = ~static_cast<uint32>(static_cast<int32>(n << 31) >> 31); + uint32_t out_3_gt = + ~static_cast<uint32_t>(static_cast<int32_t>(n << 31) >> 31); - uint32 mask = top_4_all_ones & ((out_3_equal & bottom_3_non_zero) | out_3_gt); + uint32_t mask = + top_4_all_ones & ((out_3_equal & bottom_3_non_zero) | out_3_gt); out[0] -= 1 & mask; out[3] -= 0xffff000 & mask; out[4] -= 0xfffffff & mask; @@ -421,7 +425,7 @@ const FieldElement kB = { 39211076, 180311059, 84673715, 188764328, }; -void CopyConditional(Point* out, const Point& a, uint32 mask); +void CopyConditional(Point* out, const Point& a, uint32_t mask); void DoubleJacobian(Point* out, const Point& a); // AddJacobian computes *out = a+b where a != b. @@ -431,8 +435,8 @@ void AddJacobian(Point *out, // See http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#addition-add-2007-bl FieldElement z1z1, z2z2, u1, u2, s1, s2, h, i, j, r, v; - uint32 z1_is_zero = IsZero(a.z); - uint32 z2_is_zero = IsZero(b.z); + uint32_t z1_is_zero = IsZero(a.z); + uint32_t z2_is_zero = IsZero(b.z); // Z1Z1 = Z1² Square(&z1z1, a.z); @@ -457,7 +461,7 @@ void AddJacobian(Point *out, // H = U2-U1 Subtract(&h, u2, u1); Reduce(&h); - uint32 x_equal = IsZero(h); + uint32_t x_equal = IsZero(h); // I = (2*H)² for (int k = 0; k < 8; k++) { @@ -471,7 +475,7 @@ void AddJacobian(Point *out, // r = 2*(S2-S1) Subtract(&r, s2, s1); Reduce(&r); - uint32 y_equal = IsZero(r); + uint32_t y_equal = IsZero(r); if (x_equal && y_equal && !z1_is_zero && !z2_is_zero) { // The two input points are the same therefore we must use the dedicated @@ -578,9 +582,7 @@ void DoubleJacobian(Point* out, const Point& a) { // CopyConditional sets *out=a if mask is 0xffffffff. mask must be either 0 of // 0xffffffff. -void CopyConditional(Point* out, - const Point& a, - uint32 mask) { +void CopyConditional(Point* out, const Point& a, uint32_t mask) { for (int i = 0; i < 8; i++) { out->x[i] ^= mask & (a.x[i] ^ out->x[i]); out->y[i] ^= mask & (a.y[i] ^ out->y[i]); @@ -590,15 +592,17 @@ void CopyConditional(Point* out, // ScalarMult calculates *out = a*scalar where scalar is a big-endian number of // length scalar_len and != 0. -void ScalarMult(Point* out, const Point& a, - const uint8* scalar, size_t scalar_len) { +void ScalarMult(Point* out, + const Point& a, + const uint8_t* scalar, + size_t scalar_len) { memset(out, 0, sizeof(*out)); Point tmp; for (size_t i = 0; i < scalar_len; i++) { for (unsigned int bit_num = 0; bit_num < 8; bit_num++) { DoubleJacobian(out, *out); - uint32 bit = static_cast<uint32>(static_cast<int32>( + uint32_t bit = static_cast<uint32_t>(static_cast<int32_t>( (((scalar[i] >> (7 - bit_num)) & 1) << 31) >> 31)); AddJacobian(&tmp, a, *out); CopyConditional(out, tmp, bit); @@ -608,7 +612,7 @@ void ScalarMult(Point* out, const Point& a, // Get224Bits reads 7 words from in and scatters their contents in // little-endian form into 8 words at out, 28 bits per output word. -void Get224Bits(uint32* out, const uint32* in) { +void Get224Bits(uint32_t* out, const uint32_t* in) { out[0] = NetToHost32(in[6]) & kBottom28Bits; out[1] = ((NetToHost32(in[5]) << 4) | (NetToHost32(in[6]) >> 28)) & kBottom28Bits; @@ -628,7 +632,7 @@ void Get224Bits(uint32* out, const uint32* in) { // Put224Bits performs the inverse operation to Get224Bits: taking 28 bits from // each of 8 input words and writing them in big-endian order to 7 words at // out. -void Put224Bits(uint32* out, const uint32* in) { +void Put224Bits(uint32_t* out, const uint32_t* in) { out[6] = HostToNet32((in[0] >> 0) | (in[1] << 28)); out[5] = HostToNet32((in[1] >> 4) | (in[2] << 24)); out[4] = HostToNet32((in[2] >> 8) | (in[3] << 20)); @@ -647,7 +651,7 @@ namespace p224 { bool Point::SetFromString(const base::StringPiece& in) { if (in.size() != 2*28) return false; - const uint32* inwords = reinterpret_cast<const uint32*>(in.data()); + const uint32_t* inwords = reinterpret_cast<const uint32_t*>(in.data()); Get224Bits(x, inwords); Get224Bits(y, inwords + 7); memset(&z, 0, sizeof(z)); @@ -693,13 +697,13 @@ std::string Point::ToString() const { Contract(&xx); Contract(&yy); - uint32 outwords[14]; + uint32_t outwords[14]; Put224Bits(outwords, xx); Put224Bits(outwords + 7, yy); return std::string(reinterpret_cast<const char*>(outwords), sizeof(outwords)); } -void ScalarMult(const Point& in, const uint8* scalar, Point* out) { +void ScalarMult(const Point& in, const uint8_t* scalar, Point* out) { ::ScalarMult(out, in, scalar, 28); } @@ -712,7 +716,7 @@ static const Point kBasePoint = { {1, 0, 0, 0, 0, 0, 0, 0}, }; -void ScalarBaseMult(const uint8* scalar, Point* out) { +void ScalarBaseMult(const uint8_t* scalar, Point* out) { ::ScalarMult(out, kBasePoint, scalar, 28); } diff --git a/crypto/p224.h b/crypto/p224.h index 2efecfa..e9a53a9 100644 --- a/crypto/p224.h +++ b/crypto/p224.h @@ -5,9 +5,11 @@ #ifndef CRYPTO_P224_H_ #define CRYPTO_P224_H_ +#include <stddef.h> +#include <stdint.h> + #include <string> -#include "base/basictypes.h" #include "base/strings/string_piece.h" #include "crypto/crypto_export.h" @@ -19,7 +21,7 @@ namespace p224 { // An element of the field (ℤ/pℤ) is represented with 8, 28-bit limbs in // little endian order. -typedef uint32 FieldElement[8]; +typedef uint32_t FieldElement[8]; struct CRYPTO_EXPORT Point { // SetFromString the value of the point from the 56 byte, external @@ -41,11 +43,13 @@ static const size_t kScalarBytes = 28; // ScalarMult computes *out = in*scalar where scalar is a 28-byte, big-endian // number. -void CRYPTO_EXPORT ScalarMult(const Point& in, const uint8* scalar, Point* out); +void CRYPTO_EXPORT ScalarMult(const Point& in, + const uint8_t* scalar, + Point* out); // ScalarBaseMult computes *out = g*scalar where g is the base point of the // curve and scalar is a 28-byte, big-endian number. -void CRYPTO_EXPORT ScalarBaseMult(const uint8* scalar, Point* out); +void CRYPTO_EXPORT ScalarBaseMult(const uint8_t* scalar, Point* out); // Add computes *out = a+b. void CRYPTO_EXPORT Add(const Point& a, const Point& b, Point* out); diff --git a/crypto/p224_spake.cc b/crypto/p224_spake.cc index a6dec40..1574105 100644 --- a/crypto/p224_spake.cc +++ b/crypto/p224_spake.cc @@ -203,14 +203,14 @@ P224EncryptedKeyExchange::Result P224EncryptedKeyExchange::ProcessMessage( // Now we calculate the hashes that each side will use to prove to the other // that they derived the correct value for K. - uint8 client_hash[kSHA256Length], server_hash[kSHA256Length]; + uint8_t client_hash[kSHA256Length], server_hash[kSHA256Length]; CalculateHash(kPeerTypeClient, client_masked_dh, server_masked_dh, key_, client_hash); CalculateHash(kPeerTypeServer, client_masked_dh, server_masked_dh, key_, server_hash); - const uint8* my_hash = is_server_ ? server_hash : client_hash; - const uint8* their_hash = is_server_ ? client_hash : server_hash; + const uint8_t* my_hash = is_server_ ? server_hash : client_hash; + const uint8_t* their_hash = is_server_ ? client_hash : server_hash; next_message_ = std::string(reinterpret_cast<const char*>(my_hash), kSHA256Length); @@ -224,7 +224,7 @@ void P224EncryptedKeyExchange::CalculateHash( const std::string& client_masked_dh, const std::string& server_masked_dh, const std::string& k, - uint8* out_digest) { + uint8_t* out_digest) { std::string hash_contents; if (peer_type == kPeerTypeServer) { diff --git a/crypto/p224_spake.h b/crypto/p224_spake.h index 556b15c..f9a44e7 100644 --- a/crypto/p224_spake.h +++ b/crypto/p224_spake.h @@ -5,10 +5,12 @@ #ifndef CRYPTO_P224_SPAKE_H_ #define CRYPTO_P224_SPAKE_H_ -#include <base/gtest_prod_util.h> -#include <base/strings/string_piece.h> #include <crypto/p224.h> #include <crypto/sha2.h> +#include <stdint.h> + +#include "base/gtest_prod_util.h" +#include "base/strings/string_piece.h" namespace crypto { @@ -101,22 +103,21 @@ class CRYPTO_EXPORT P224EncryptedKeyExchange { // CalculateHash computes the verification hash for the given peer and writes // |kSHA256Length| bytes at |out_digest|. - void CalculateHash( - PeerType peer_type, - const std::string& client_masked_dh, - const std::string& server_masked_dh, - const std::string& k, - uint8* out_digest); + void CalculateHash(PeerType peer_type, + const std::string& client_masked_dh, + const std::string& server_masked_dh, + const std::string& k, + uint8_t* out_digest); // x_ is the secret Diffie-Hellman exponent (see paper referenced in .cc // file). - uint8 x_[p224::kScalarBytes]; - // pw_ is SHA256(P(password), P(session))[:28] where P() prepends a uint32, + uint8_t x_[p224::kScalarBytes]; + // pw_ is SHA256(P(password), P(session))[:28] where P() prepends a uint32_t, // big-endian length prefix (see paper referenced in .cc file). - uint8 pw_[p224::kScalarBytes]; + uint8_t pw_[p224::kScalarBytes]; // expected_authenticator_ is used to store the hash value expected from the // other party. - uint8 expected_authenticator_[kSHA256Length]; + uint8_t expected_authenticator_[kSHA256Length]; std::string key_; }; diff --git a/crypto/p224_spake_unittest.cc b/crypto/p224_spake_unittest.cc index 15b5be2..3bca430 100644 --- a/crypto/p224_spake_unittest.cc +++ b/crypto/p224_spake_unittest.cc @@ -4,6 +4,9 @@ #include "crypto/p224_spake.h" +#include <stddef.h> +#include <stdint.h> + #include <string> #include "base/logging.h" @@ -125,7 +128,7 @@ TEST(MutualAuth, Fuzz) { // We'll only be testing small values of i, but we don't want that to bias // the test coverage. So we disperse the value of i by multiplying by the // FNV, 32-bit prime, producing a poor-man's PRNG. - const uint32 rand = i * 16777619; + const uint32_t rand = i * 16777619; for (unsigned round = 0;; round++) { std::string client_message, server_message; diff --git a/crypto/p224_unittest.cc b/crypto/p224_unittest.cc index aaf5f59..faa08eb 100644 --- a/crypto/p224_unittest.cc +++ b/crypto/p224_unittest.cc @@ -2,11 +2,14 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include <string.h> +#include <stddef.h> +#include <stdint.h> #include <stdio.h> +#include <string.h> #include "crypto/p224.h" +#include "base/macros.h" #include "testing/gtest/include/gtest/gtest.h" namespace crypto { @@ -14,22 +17,20 @@ namespace crypto { using p224::Point; // kBasePointExternal is the P224 base point in external representation. -static const uint8 kBasePointExternal[56] = { - 0xb7, 0x0e, 0x0c, 0xbd, 0x6b, 0xb4, 0xbf, 0x7f, - 0x32, 0x13, 0x90, 0xb9, 0x4a, 0x03, 0xc1, 0xd3, - 0x56, 0xc2, 0x11, 0x22, 0x34, 0x32, 0x80, 0xd6, - 0x11, 0x5c, 0x1d, 0x21, 0xbd, 0x37, 0x63, 0x88, - 0xb5, 0xf7, 0x23, 0xfb, 0x4c, 0x22, 0xdf, 0xe6, - 0xcd, 0x43, 0x75, 0xa0, 0x5a, 0x07, 0x47, 0x64, - 0x44, 0xd5, 0x81, 0x99, 0x85, 0x00, 0x7e, 0x34, +static const uint8_t kBasePointExternal[56] = { + 0xb7, 0x0e, 0x0c, 0xbd, 0x6b, 0xb4, 0xbf, 0x7f, 0x32, 0x13, 0x90, 0xb9, + 0x4a, 0x03, 0xc1, 0xd3, 0x56, 0xc2, 0x11, 0x22, 0x34, 0x32, 0x80, 0xd6, + 0x11, 0x5c, 0x1d, 0x21, 0xbd, 0x37, 0x63, 0x88, 0xb5, 0xf7, 0x23, 0xfb, + 0x4c, 0x22, 0xdf, 0xe6, 0xcd, 0x43, 0x75, 0xa0, 0x5a, 0x07, 0x47, 0x64, + 0x44, 0xd5, 0x81, 0x99, 0x85, 0x00, 0x7e, 0x34, }; // TestVector represents a test of scalar multiplication of the base point. // |scalar| is a big-endian scalar and |affine| is the external representation // of g*scalar. struct TestVector { - uint8 scalar[28]; - uint8 affine[28*2]; + uint8_t scalar[28]; + uint8_t affine[28 * 2]; }; static const int kNumNISTTestVectors = 52; @@ -814,7 +815,7 @@ TEST(P224, Infinity) { // Test that x^0 = ∞. Point a; - p224::ScalarBaseMult(reinterpret_cast<const uint8*>(zeros), &a); + p224::ScalarBaseMult(reinterpret_cast<const uint8_t*>(zeros), &a); EXPECT_TRUE(memcmp(zeros, a.ToString().data(), sizeof(zeros)) == 0); // We shouldn't allow ∞ to be imported. diff --git a/crypto/random.cc b/crypto/random.cc index a19bb1a..355914e 100644 --- a/crypto/random.cc +++ b/crypto/random.cc @@ -4,6 +4,8 @@ #include "crypto/random.h" +#include <stddef.h> + #include "base/rand_util.h" namespace crypto { diff --git a/crypto/random_unittest.cc b/crypto/random_unittest.cc index 00d4b2b..caee512 100644 --- a/crypto/random_unittest.cc +++ b/crypto/random_unittest.cc @@ -4,6 +4,8 @@ #include "crypto/random.h" +#include <stddef.h> + #include "base/strings/string_util.h" #include "testing/gtest/include/gtest/gtest.h" diff --git a/crypto/rsa_private_key.cc b/crypto/rsa_private_key.cc index 92c4f70..c546c91 100644 --- a/crypto/rsa_private_key.cc +++ b/crypto/rsa_private_key.cc @@ -4,6 +4,9 @@ #include "crypto/rsa_private_key.h" +#include <stddef.h> +#include <stdint.h> + #include <algorithm> #include "base/logging.h" @@ -43,21 +46,20 @@ namespace { namespace crypto { -const uint8 PrivateKeyInfoCodec::kRsaAlgorithmIdentifier[] = { - 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, - 0x05, 0x00 -}; +const uint8_t PrivateKeyInfoCodec::kRsaAlgorithmIdentifier[] = { + 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, + 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00}; PrivateKeyInfoCodec::PrivateKeyInfoCodec(bool big_endian) : big_endian_(big_endian) {} PrivateKeyInfoCodec::~PrivateKeyInfoCodec() {} -bool PrivateKeyInfoCodec::Export(std::vector<uint8>* output) { - std::list<uint8> content; +bool PrivateKeyInfoCodec::Export(std::vector<uint8_t>* output) { + std::list<uint8_t> content; // Version (always zero) - uint8 version = 0; + uint8_t version = 0; PrependInteger(coefficient_, &content); PrependInteger(exponent2_, &content); @@ -85,14 +87,14 @@ bool PrivateKeyInfoCodec::Export(std::vector<uint8>* output) { return true; } -bool PrivateKeyInfoCodec::ExportPublicKeyInfo(std::vector<uint8>* output) { +bool PrivateKeyInfoCodec::ExportPublicKeyInfo(std::vector<uint8_t>* output) { // Create a sequence with the modulus (n) and public exponent (e). - std::vector<uint8> bit_string; + std::vector<uint8_t> bit_string; if (!ExportPublicKey(&bit_string)) return false; // Add the sequence as the contents of a bit string. - std::list<uint8> content; + std::list<uint8_t> content; PrependBitString(&bit_string[0], static_cast<int>(bit_string.size()), &content); @@ -110,9 +112,9 @@ bool PrivateKeyInfoCodec::ExportPublicKeyInfo(std::vector<uint8>* output) { return true; } -bool PrivateKeyInfoCodec::ExportPublicKey(std::vector<uint8>* output) { +bool PrivateKeyInfoCodec::ExportPublicKey(std::vector<uint8_t>* output) { // Create a sequence with the modulus (n) and public exponent (e). - std::list<uint8> content; + std::list<uint8_t> content; PrependInteger(&public_exponent_[0], static_cast<int>(public_exponent_.size()), &content); @@ -126,15 +128,15 @@ bool PrivateKeyInfoCodec::ExportPublicKey(std::vector<uint8>* output) { return true; } -bool PrivateKeyInfoCodec::Import(const std::vector<uint8>& input) { +bool PrivateKeyInfoCodec::Import(const std::vector<uint8_t>& input) { if (input.empty()) { return false; } // Parse the private key info up to the public key values, ignoring // the subsequent private key values. - uint8* src = const_cast<uint8*>(&input.front()); - uint8* end = src + input.size(); + uint8_t* src = const_cast<uint8_t*>(&input.front()); + uint8_t* end = src + input.size(); if (!ReadSequence(&src, end) || !ReadVersion(&src, end) || !ReadAlgorithmIdentifier(&src, end) || @@ -163,25 +165,25 @@ bool PrivateKeyInfoCodec::Import(const std::vector<uint8>& input) { return true; } -void PrivateKeyInfoCodec::PrependInteger(const std::vector<uint8>& in, - std::list<uint8>* out) { - uint8* ptr = const_cast<uint8*>(&in.front()); +void PrivateKeyInfoCodec::PrependInteger(const std::vector<uint8_t>& in, + std::list<uint8_t>* out) { + uint8_t* ptr = const_cast<uint8_t*>(&in.front()); PrependIntegerImpl(ptr, in.size(), out, big_endian_); } // Helper to prepend an ASN.1 integer. -void PrivateKeyInfoCodec::PrependInteger(uint8* val, +void PrivateKeyInfoCodec::PrependInteger(uint8_t* val, int num_bytes, - std::list<uint8>* data) { + std::list<uint8_t>* data) { PrependIntegerImpl(val, num_bytes, data, big_endian_); } -void PrivateKeyInfoCodec::PrependIntegerImpl(uint8* val, +void PrivateKeyInfoCodec::PrependIntegerImpl(uint8_t* val, int num_bytes, - std::list<uint8>* data, + std::list<uint8_t>* data, bool big_endian) { // Reverse input if little-endian. - std::vector<uint8> tmp; + std::vector<uint8_t> tmp; if (!big_endian) { tmp.assign(val, val + num_bytes); std::reverse(tmp.begin(), tmp.end()); @@ -201,7 +203,7 @@ void PrivateKeyInfoCodec::PrependIntegerImpl(uint8* val, // (the most significant bit) would otherwise be set and make the number // negative, ASN.1 requires a leading null byte to force the integer to be // positive. - uint8 front = data->front(); + uint8_t front = data->front(); if ((front & 0x80) != 0) { data->push_front(0x00); num_bytes++; @@ -210,17 +212,18 @@ void PrivateKeyInfoCodec::PrependIntegerImpl(uint8* val, PrependTypeHeaderAndLength(kIntegerTag, num_bytes, data); } -bool PrivateKeyInfoCodec::ReadInteger(uint8** pos, - uint8* end, - std::vector<uint8>* out) { +bool PrivateKeyInfoCodec::ReadInteger(uint8_t** pos, + uint8_t* end, + std::vector<uint8_t>* out) { return ReadIntegerImpl(pos, end, out, big_endian_); } -bool PrivateKeyInfoCodec::ReadIntegerWithExpectedSize(uint8** pos, - uint8* end, - size_t expected_size, - std::vector<uint8>* out) { - std::vector<uint8> temp; +bool PrivateKeyInfoCodec::ReadIntegerWithExpectedSize( + uint8_t** pos, + uint8_t* end, + size_t expected_size, + std::vector<uint8_t>* out) { + std::vector<uint8_t> temp; if (!ReadIntegerImpl(pos, end, &temp, true)) // Big-Endian return false; @@ -243,11 +246,11 @@ bool PrivateKeyInfoCodec::ReadIntegerWithExpectedSize(uint8** pos, return true; } -bool PrivateKeyInfoCodec::ReadIntegerImpl(uint8** pos, - uint8* end, - std::vector<uint8>* out, +bool PrivateKeyInfoCodec::ReadIntegerImpl(uint8_t** pos, + uint8_t* end, + std::vector<uint8_t>* out, bool big_endian) { - uint32 length = 0; + uint32_t length = 0; if (!ReadTypeHeaderAndLength(pos, end, kIntegerTag, &length) || !length) return false; @@ -268,25 +271,25 @@ bool PrivateKeyInfoCodec::ReadIntegerImpl(uint8** pos, return true; } -void PrivateKeyInfoCodec::PrependBytes(uint8* val, +void PrivateKeyInfoCodec::PrependBytes(uint8_t* val, int start, int num_bytes, - std::list<uint8>* data) { + std::list<uint8_t>* data) { while (num_bytes > 0) { --num_bytes; data->push_front(val[start + num_bytes]); } } -void PrivateKeyInfoCodec::PrependLength(size_t size, std::list<uint8>* data) { +void PrivateKeyInfoCodec::PrependLength(size_t size, std::list<uint8_t>* data) { // The high bit is used to indicate whether additional octets are needed to // represent the length. if (size < 0x80) { - data->push_front(static_cast<uint8>(size)); + data->push_front(static_cast<uint8_t>(size)); } else { - uint8 num_bytes = 0; + uint8_t num_bytes = 0; while (size > 0) { - data->push_front(static_cast<uint8>(size & 0xFF)); + data->push_front(static_cast<uint8_t>(size & 0xFF)); size >>= 8; num_bytes++; } @@ -295,16 +298,17 @@ void PrivateKeyInfoCodec::PrependLength(size_t size, std::list<uint8>* data) { } } -void PrivateKeyInfoCodec::PrependTypeHeaderAndLength(uint8 type, - uint32 length, - std::list<uint8>* output) { +void PrivateKeyInfoCodec::PrependTypeHeaderAndLength( + uint8_t type, + uint32_t length, + std::list<uint8_t>* output) { PrependLength(length, output); output->push_front(type); } -void PrivateKeyInfoCodec::PrependBitString(uint8* val, +void PrivateKeyInfoCodec::PrependBitString(uint8_t* val, int num_bytes, - std::list<uint8>* output) { + std::list<uint8_t>* output) { // Start with the data. PrependBytes(val, 0, num_bytes, output); // Zero unused bits. @@ -312,10 +316,12 @@ void PrivateKeyInfoCodec::PrependBitString(uint8* val, // Add the length. PrependLength(num_bytes + 1, output); // Finally, add the bit string tag. - output->push_front((uint8) kBitStringTag); + output->push_front((uint8_t)kBitStringTag); } -bool PrivateKeyInfoCodec::ReadLength(uint8** pos, uint8* end, uint32* result) { +bool PrivateKeyInfoCodec::ReadLength(uint8_t** pos, + uint8_t* end, + uint32_t* result) { READ_ASSERT(*pos < end); int length = 0; @@ -343,10 +349,10 @@ bool PrivateKeyInfoCodec::ReadLength(uint8** pos, uint8* end, uint32* result) { return true; } -bool PrivateKeyInfoCodec::ReadTypeHeaderAndLength(uint8** pos, - uint8* end, - uint8 expected_tag, - uint32* length) { +bool PrivateKeyInfoCodec::ReadTypeHeaderAndLength(uint8_t** pos, + uint8_t* end, + uint8_t expected_tag, + uint32_t* length) { READ_ASSERT(*pos < end); READ_ASSERT(**pos == expected_tag); (*pos)++; @@ -354,11 +360,11 @@ bool PrivateKeyInfoCodec::ReadTypeHeaderAndLength(uint8** pos, return ReadLength(pos, end, length); } -bool PrivateKeyInfoCodec::ReadSequence(uint8** pos, uint8* end) { +bool PrivateKeyInfoCodec::ReadSequence(uint8_t** pos, uint8_t* end) { return ReadTypeHeaderAndLength(pos, end, kSequenceTag, NULL); } -bool PrivateKeyInfoCodec::ReadAlgorithmIdentifier(uint8** pos, uint8* end) { +bool PrivateKeyInfoCodec::ReadAlgorithmIdentifier(uint8_t** pos, uint8_t* end) { READ_ASSERT(*pos + sizeof(kRsaAlgorithmIdentifier) < end); READ_ASSERT(memcmp(*pos, kRsaAlgorithmIdentifier, sizeof(kRsaAlgorithmIdentifier)) == 0); @@ -366,13 +372,13 @@ bool PrivateKeyInfoCodec::ReadAlgorithmIdentifier(uint8** pos, uint8* end) { return true; } -bool PrivateKeyInfoCodec::ReadVersion(uint8** pos, uint8* end) { - uint32 length = 0; +bool PrivateKeyInfoCodec::ReadVersion(uint8_t** pos, uint8_t* end) { + uint32_t length = 0; if (!ReadTypeHeaderAndLength(pos, end, kIntegerTag, &length)) return false; // The version should be zero. - for (uint32 i = 0; i < length; ++i) { + for (uint32_t i = 0; i < length; ++i) { READ_ASSERT(**pos == 0x00); (*pos)++; } diff --git a/crypto/rsa_private_key.h b/crypto/rsa_private_key.h index fdcb392..9703334 100644 --- a/crypto/rsa_private_key.h +++ b/crypto/rsa_private_key.h @@ -5,10 +5,13 @@ #ifndef CRYPTO_RSA_PRIVATE_KEY_H_ #define CRYPTO_RSA_PRIVATE_KEY_H_ +#include <stddef.h> +#include <stdint.h> + #include <list> #include <vector> -#include "base/basictypes.h" +#include "base/macros.h" #include "build/build_config.h" #include "crypto/crypto_export.h" @@ -30,14 +33,14 @@ namespace crypto { class PrivateKeyInfoCodec { public: // ASN.1 encoding of the AlgorithmIdentifier from PKCS #8. - static const uint8 kRsaAlgorithmIdentifier[]; + static const uint8_t kRsaAlgorithmIdentifier[]; // ASN.1 tags for some types we use. - static const uint8 kBitStringTag = 0x03; - static const uint8 kIntegerTag = 0x02; - static const uint8 kNullTag = 0x05; - static const uint8 kOctetStringTag = 0x04; - static const uint8 kSequenceTag = 0x30; + static const uint8_t kBitStringTag = 0x03; + static const uint8_t kIntegerTag = 0x02; + static const uint8_t kNullTag = 0x05; + static const uint8_t kOctetStringTag = 0x04; + static const uint8_t kSequenceTag = 0x30; // |big_endian| here specifies the byte-significance of the integer components // that will be parsed & serialized (modulus(), etc...) during Import(), @@ -49,111 +52,113 @@ class PrivateKeyInfoCodec { // Exports the contents of the integer components to the ASN.1 DER encoding // of the PrivateKeyInfo structure to |output|. - bool Export(std::vector<uint8>* output); + bool Export(std::vector<uint8_t>* output); // Exports the contents of the integer components to the ASN.1 DER encoding // of the PublicKeyInfo structure to |output|. - bool ExportPublicKeyInfo(std::vector<uint8>* output); + bool ExportPublicKeyInfo(std::vector<uint8_t>* output); // Exports the contents of the integer components to the ASN.1 DER encoding // of the RSAPublicKey structure to |output|. - bool ExportPublicKey(std::vector<uint8>* output); + bool ExportPublicKey(std::vector<uint8_t>* output); // Parses the ASN.1 DER encoding of the PrivateKeyInfo structure in |input| // and populates the integer components with |big_endian_| byte-significance. // IMPORTANT NOTE: This is currently *not* security-approved for importing // keys from unstrusted sources. - bool Import(const std::vector<uint8>& input); + bool Import(const std::vector<uint8_t>& input); // Accessors to the contents of the integer components of the PrivateKeyInfo // structure. - std::vector<uint8>* modulus() { return &modulus_; } - std::vector<uint8>* public_exponent() { return &public_exponent_; } - std::vector<uint8>* private_exponent() { return &private_exponent_; } - std::vector<uint8>* prime1() { return &prime1_; } - std::vector<uint8>* prime2() { return &prime2_; } - std::vector<uint8>* exponent1() { return &exponent1_; } - std::vector<uint8>* exponent2() { return &exponent2_; } - std::vector<uint8>* coefficient() { return &coefficient_; } + std::vector<uint8_t>* modulus() { return &modulus_; } + std::vector<uint8_t>* public_exponent() { return &public_exponent_; } + std::vector<uint8_t>* private_exponent() { return &private_exponent_; } + std::vector<uint8_t>* prime1() { return &prime1_; } + std::vector<uint8_t>* prime2() { return &prime2_; } + std::vector<uint8_t>* exponent1() { return &exponent1_; } + std::vector<uint8_t>* exponent2() { return &exponent2_; } + std::vector<uint8_t>* coefficient() { return &coefficient_; } private: // Utility wrappers for PrependIntegerImpl that use the class's |big_endian_| // value. - void PrependInteger(const std::vector<uint8>& in, std::list<uint8>* out); - void PrependInteger(uint8* val, int num_bytes, std::list<uint8>* data); + void PrependInteger(const std::vector<uint8_t>& in, std::list<uint8_t>* out); + void PrependInteger(uint8_t* val, int num_bytes, std::list<uint8_t>* data); // Prepends the integer stored in |val| - |val + num_bytes| with |big_endian| // byte-significance into |data| as an ASN.1 integer. - void PrependIntegerImpl(uint8* val, + void PrependIntegerImpl(uint8_t* val, int num_bytes, - std::list<uint8>* data, + std::list<uint8_t>* data, bool big_endian); // Utility wrappers for ReadIntegerImpl that use the class's |big_endian_| // value. - bool ReadInteger(uint8** pos, uint8* end, std::vector<uint8>* out); - bool ReadIntegerWithExpectedSize(uint8** pos, - uint8* end, + bool ReadInteger(uint8_t** pos, uint8_t* end, std::vector<uint8_t>* out); + bool ReadIntegerWithExpectedSize(uint8_t** pos, + uint8_t* end, size_t expected_size, - std::vector<uint8>* out); + std::vector<uint8_t>* out); // Reads an ASN.1 integer from |pos|, and stores the result into |out| with // |big_endian| byte-significance. - bool ReadIntegerImpl(uint8** pos, - uint8* end, - std::vector<uint8>* out, + bool ReadIntegerImpl(uint8_t** pos, + uint8_t* end, + std::vector<uint8_t>* out, bool big_endian); // Prepends the integer stored in |val|, starting a index |start|, for // |num_bytes| bytes onto |data|. - void PrependBytes(uint8* val, + void PrependBytes(uint8_t* val, int start, int num_bytes, - std::list<uint8>* data); + std::list<uint8_t>* data); // Helper to prepend an ASN.1 length field. - void PrependLength(size_t size, std::list<uint8>* data); + void PrependLength(size_t size, std::list<uint8_t>* data); // Helper to prepend an ASN.1 type header. - void PrependTypeHeaderAndLength(uint8 type, - uint32 length, - std::list<uint8>* output); + void PrependTypeHeaderAndLength(uint8_t type, + uint32_t length, + std::list<uint8_t>* output); // Helper to prepend an ASN.1 bit string - void PrependBitString(uint8* val, int num_bytes, std::list<uint8>* output); + void PrependBitString(uint8_t* val, + int num_bytes, + std::list<uint8_t>* output); // Read an ASN.1 length field. This also checks that the length does not // extend beyond |end|. - bool ReadLength(uint8** pos, uint8* end, uint32* result); + bool ReadLength(uint8_t** pos, uint8_t* end, uint32_t* result); // Read an ASN.1 type header and its length. - bool ReadTypeHeaderAndLength(uint8** pos, - uint8* end, - uint8 expected_tag, - uint32* length); + bool ReadTypeHeaderAndLength(uint8_t** pos, + uint8_t* end, + uint8_t expected_tag, + uint32_t* length); // Read an ASN.1 sequence declaration. This consumes the type header and // length field, but not the contents of the sequence. - bool ReadSequence(uint8** pos, uint8* end); + bool ReadSequence(uint8_t** pos, uint8_t* end); // Read the RSA AlgorithmIdentifier. - bool ReadAlgorithmIdentifier(uint8** pos, uint8* end); + bool ReadAlgorithmIdentifier(uint8_t** pos, uint8_t* end); // Read one of the two version fields in PrivateKeyInfo. - bool ReadVersion(uint8** pos, uint8* end); + bool ReadVersion(uint8_t** pos, uint8_t* end); // The byte-significance of the stored components (modulus, etc..). bool big_endian_; // Component integers of the PrivateKeyInfo - std::vector<uint8> modulus_; - std::vector<uint8> public_exponent_; - std::vector<uint8> private_exponent_; - std::vector<uint8> prime1_; - std::vector<uint8> prime2_; - std::vector<uint8> exponent1_; - std::vector<uint8> exponent2_; - std::vector<uint8> coefficient_; + std::vector<uint8_t> modulus_; + std::vector<uint8_t> public_exponent_; + std::vector<uint8_t> private_exponent_; + std::vector<uint8_t> prime1_; + std::vector<uint8_t> prime2_; + std::vector<uint8_t> exponent1_; + std::vector<uint8_t> exponent2_; + std::vector<uint8_t> coefficient_; DISALLOW_COPY_AND_ASSIGN(PrivateKeyInfoCodec); }; @@ -166,13 +171,13 @@ class CRYPTO_EXPORT RSAPrivateKey { ~RSAPrivateKey(); // Create a new random instance. Can return NULL if initialization fails. - static RSAPrivateKey* Create(uint16 num_bits); + static RSAPrivateKey* Create(uint16_t num_bits); // Create a new instance by importing an existing private key. The format is // an ASN.1-encoded PrivateKeyInfo block from PKCS #8. This can return NULL if // initialization fails. static RSAPrivateKey* CreateFromPrivateKeyInfo( - const std::vector<uint8>& input); + const std::vector<uint8_t>& input); #if defined(USE_OPENSSL) // Create a new instance from an existing EVP_PKEY, taking a @@ -196,10 +201,10 @@ class CRYPTO_EXPORT RSAPrivateKey { RSAPrivateKey* Copy() const; // Exports the private key to a PKCS #1 PrivateKey block. - bool ExportPrivateKey(std::vector<uint8>* output) const; + bool ExportPrivateKey(std::vector<uint8_t>* output) const; // Exports the public key to an X509 SubjectPublicKeyInfo block. - bool ExportPublicKey(std::vector<uint8>* output) const; + bool ExportPublicKey(std::vector<uint8_t>* output) const; private: // Constructor is private. Use one of the Create*() methods above instead. diff --git a/crypto/rsa_private_key_nss.cc b/crypto/rsa_private_key_nss.cc index 88e55fa..349b7ea 100644 --- a/crypto/rsa_private_key_nss.cc +++ b/crypto/rsa_private_key_nss.cc @@ -7,6 +7,7 @@ #include <cryptohi.h> #include <keyhi.h> #include <pk11pub.h> +#include <stdint.h> #include <list> @@ -23,7 +24,7 @@ namespace { static bool ReadAttribute(SECKEYPrivateKey* key, CK_ATTRIBUTE_TYPE type, - std::vector<uint8>* output) { + std::vector<uint8_t>* output) { SECItem item; SECStatus rv; rv = PK11_ReadRawAttribute(PK11_TypePrivKey, key, type, &item); @@ -49,7 +50,7 @@ RSAPrivateKey::~RSAPrivateKey() { } // static -RSAPrivateKey* RSAPrivateKey::Create(uint16 num_bits) { +RSAPrivateKey* RSAPrivateKey::Create(uint16_t num_bits) { EnsureNSSInit(); ScopedPK11Slot slot(PK11_GetInternalSlot()); @@ -73,7 +74,7 @@ RSAPrivateKey* RSAPrivateKey::Create(uint16 num_bits) { // static RSAPrivateKey* RSAPrivateKey::CreateFromPrivateKeyInfo( - const std::vector<uint8>& input) { + const std::vector<uint8_t>& input) { EnsureNSSInit(); ScopedPK11Slot slot(PK11_GetInternalSlot()); @@ -111,7 +112,7 @@ RSAPrivateKey* RSAPrivateKey::Copy() const { return copy; } -bool RSAPrivateKey::ExportPrivateKey(std::vector<uint8>* output) const { +bool RSAPrivateKey::ExportPrivateKey(std::vector<uint8_t>* output) const { PrivateKeyInfoCodec private_key_info(true); // Manually read the component attributes of the private key and build up @@ -133,7 +134,7 @@ bool RSAPrivateKey::ExportPrivateKey(std::vector<uint8>* output) const { return private_key_info.Export(output); } -bool RSAPrivateKey::ExportPublicKey(std::vector<uint8>* output) const { +bool RSAPrivateKey::ExportPublicKey(std::vector<uint8_t>* output) const { ScopedSECItem der_pubkey(SECKEY_EncodeDERSubjectPublicKeyInfo(public_key_)); if (!der_pubkey.get()) { NOTREACHED(); diff --git a/crypto/rsa_private_key_openssl.cc b/crypto/rsa_private_key_openssl.cc index 52a0a7a..f7fdd9d 100644 --- a/crypto/rsa_private_key_openssl.cc +++ b/crypto/rsa_private_key_openssl.cc @@ -9,6 +9,7 @@ #include <openssl/evp.h> #include <openssl/pkcs12.h> #include <openssl/rsa.h> +#include <stdint.h> #include "base/logging.h" #include "base/memory/scoped_ptr.h" @@ -30,7 +31,7 @@ using ExportFunction = int (*)(BIO*, EVP_PKEY*); // Helper to export |key| into |output| via the specified ExportFunction. bool ExportKey(EVP_PKEY* key, ExportFunction export_fn, - std::vector<uint8>* output) { + std::vector<uint8_t>* output) { if (!key) return false; @@ -53,7 +54,7 @@ bool ExportKey(EVP_PKEY* key, } // namespace // static -RSAPrivateKey* RSAPrivateKey::Create(uint16 num_bits) { +RSAPrivateKey* RSAPrivateKey::Create(uint16_t num_bits) { OpenSSLErrStackTracer err_tracer(FROM_HERE); ScopedRSA rsa_key(RSA_new()); @@ -74,7 +75,7 @@ RSAPrivateKey* RSAPrivateKey::Create(uint16 num_bits) { // static RSAPrivateKey* RSAPrivateKey::CreateFromPrivateKeyInfo( - const std::vector<uint8>& input) { + const std::vector<uint8_t>& input) { if (input.empty()) return NULL; @@ -127,11 +128,11 @@ RSAPrivateKey* RSAPrivateKey::Copy() const { return copy.release(); } -bool RSAPrivateKey::ExportPrivateKey(std::vector<uint8>* output) const { +bool RSAPrivateKey::ExportPrivateKey(std::vector<uint8_t>* output) const { return ExportKey(key_, i2d_PKCS8PrivateKeyInfo_bio, output); } -bool RSAPrivateKey::ExportPublicKey(std::vector<uint8>* output) const { +bool RSAPrivateKey::ExportPublicKey(std::vector<uint8_t>* output) const { return ExportKey(key_, i2d_PUBKEY_bio, output); } diff --git a/crypto/rsa_private_key_unittest.cc b/crypto/rsa_private_key_unittest.cc index 9e7f6ff..1401e3d 100644 --- a/crypto/rsa_private_key_unittest.cc +++ b/crypto/rsa_private_key_unittest.cc @@ -4,93 +4,67 @@ #include "crypto/rsa_private_key.h" +#include <stdint.h> + #include "base/memory/scoped_ptr.h" #include "testing/gtest/include/gtest/gtest.h" namespace { -const uint8 kTestPrivateKeyInfo[] = { - 0x30, 0x82, 0x02, 0x78, 0x02, 0x01, 0x00, 0x30, - 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, - 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82, - 0x02, 0x62, 0x30, 0x82, 0x02, 0x5e, 0x02, 0x01, - 0x00, 0x02, 0x81, 0x81, 0x00, 0xb8, 0x7f, 0x2b, - 0x20, 0xdc, 0x7c, 0x9b, 0x0c, 0xdc, 0x51, 0x61, - 0x99, 0x0d, 0x36, 0x0f, 0xd4, 0x66, 0x88, 0x08, - 0x55, 0x84, 0xd5, 0x3a, 0xbf, 0x2b, 0xa4, 0x64, - 0x85, 0x7b, 0x0c, 0x04, 0x13, 0x3f, 0x8d, 0xf4, - 0xbc, 0x38, 0x0d, 0x49, 0xfe, 0x6b, 0xc4, 0x5a, - 0xb0, 0x40, 0x53, 0x3a, 0xd7, 0x66, 0x09, 0x0f, - 0x9e, 0x36, 0x74, 0x30, 0xda, 0x8a, 0x31, 0x4f, - 0x1f, 0x14, 0x50, 0xd7, 0xc7, 0x20, 0x94, 0x17, - 0xde, 0x4e, 0xb9, 0x57, 0x5e, 0x7e, 0x0a, 0xe5, - 0xb2, 0x65, 0x7a, 0x89, 0x4e, 0xb6, 0x47, 0xff, - 0x1c, 0xbd, 0xb7, 0x38, 0x13, 0xaf, 0x47, 0x85, - 0x84, 0x32, 0x33, 0xf3, 0x17, 0x49, 0xbf, 0xe9, - 0x96, 0xd0, 0xd6, 0x14, 0x6f, 0x13, 0x8d, 0xc5, - 0xfc, 0x2c, 0x72, 0xba, 0xac, 0xea, 0x7e, 0x18, - 0x53, 0x56, 0xa6, 0x83, 0xa2, 0xce, 0x93, 0x93, - 0xe7, 0x1f, 0x0f, 0xe6, 0x0f, 0x02, 0x03, 0x01, - 0x00, 0x01, 0x02, 0x81, 0x80, 0x03, 0x61, 0x89, - 0x37, 0xcb, 0xf2, 0x98, 0xa0, 0xce, 0xb4, 0xcb, - 0x16, 0x13, 0xf0, 0xe6, 0xaf, 0x5c, 0xc5, 0xa7, - 0x69, 0x71, 0xca, 0xba, 0x8d, 0xe0, 0x4d, 0xdd, - 0xed, 0xb8, 0x48, 0x8b, 0x16, 0x93, 0x36, 0x95, - 0xc2, 0x91, 0x40, 0x65, 0x17, 0xbd, 0x7f, 0xd6, - 0xad, 0x9e, 0x30, 0x28, 0x46, 0xe4, 0x3e, 0xcc, - 0x43, 0x78, 0xf9, 0xfe, 0x1f, 0x33, 0x23, 0x1e, - 0x31, 0x12, 0x9d, 0x3c, 0xa7, 0x08, 0x82, 0x7b, - 0x7d, 0x25, 0x4e, 0x5e, 0x19, 0xa8, 0x9b, 0xed, - 0x86, 0xb2, 0xcb, 0x3c, 0xfe, 0x4e, 0xa1, 0xfa, - 0x62, 0x87, 0x3a, 0x17, 0xf7, 0x60, 0xec, 0x38, - 0x29, 0xe8, 0x4f, 0x34, 0x9f, 0x76, 0x9d, 0xee, - 0xa3, 0xf6, 0x85, 0x6b, 0x84, 0x43, 0xc9, 0x1e, - 0x01, 0xff, 0xfd, 0xd0, 0x29, 0x4c, 0xfa, 0x8e, - 0x57, 0x0c, 0xc0, 0x71, 0xa5, 0xbb, 0x88, 0x46, - 0x29, 0x5c, 0xc0, 0x4f, 0x01, 0x02, 0x41, 0x00, - 0xf5, 0x83, 0xa4, 0x64, 0x4a, 0xf2, 0xdd, 0x8c, - 0x2c, 0xed, 0xa8, 0xd5, 0x60, 0x5a, 0xe4, 0xc7, - 0xcc, 0x61, 0xcd, 0x38, 0x42, 0x20, 0xd3, 0x82, - 0x18, 0xf2, 0x35, 0x00, 0x72, 0x2d, 0xf7, 0x89, - 0x80, 0x67, 0xb5, 0x93, 0x05, 0x5f, 0xdd, 0x42, - 0xba, 0x16, 0x1a, 0xea, 0x15, 0xc6, 0xf0, 0xb8, - 0x8c, 0xbc, 0xbf, 0x54, 0x9e, 0xf1, 0xc1, 0xb2, - 0xb3, 0x8b, 0xb6, 0x26, 0x02, 0x30, 0xc4, 0x81, - 0x02, 0x41, 0x00, 0xc0, 0x60, 0x62, 0x80, 0xe1, - 0x22, 0x78, 0xf6, 0x9d, 0x83, 0x18, 0xeb, 0x72, - 0x45, 0xd7, 0xc8, 0x01, 0x7f, 0xa9, 0xca, 0x8f, - 0x7d, 0xd6, 0xb8, 0x31, 0x2b, 0x84, 0x7f, 0x62, - 0xd9, 0xa9, 0x22, 0x17, 0x7d, 0x06, 0x35, 0x6c, - 0xf3, 0xc1, 0x94, 0x17, 0x85, 0x5a, 0xaf, 0x9c, - 0x5c, 0x09, 0x3c, 0xcf, 0x2f, 0x44, 0x9d, 0xb6, - 0x52, 0x68, 0x5f, 0xf9, 0x59, 0xc8, 0x84, 0x2b, - 0x39, 0x22, 0x8f, 0x02, 0x41, 0x00, 0xb2, 0x04, - 0xe2, 0x0e, 0x56, 0xca, 0x03, 0x1a, 0xc0, 0xf9, - 0x12, 0x92, 0xa5, 0x6b, 0x42, 0xb8, 0x1c, 0xda, - 0x4d, 0x93, 0x9d, 0x5f, 0x6f, 0xfd, 0xc5, 0x58, - 0xda, 0x55, 0x98, 0x74, 0xfc, 0x28, 0x17, 0x93, - 0x1b, 0x75, 0x9f, 0x50, 0x03, 0x7f, 0x7e, 0xae, - 0xc8, 0x95, 0x33, 0x75, 0x2c, 0xd6, 0xa4, 0x35, - 0xb8, 0x06, 0x03, 0xba, 0x08, 0x59, 0x2b, 0x17, - 0x02, 0xdc, 0x4c, 0x7a, 0x50, 0x01, 0x02, 0x41, - 0x00, 0x9d, 0xdb, 0x39, 0x59, 0x09, 0xe4, 0x30, - 0xa0, 0x24, 0xf5, 0xdb, 0x2f, 0xf0, 0x2f, 0xf1, - 0x75, 0x74, 0x0d, 0x5e, 0xb5, 0x11, 0x73, 0xb0, - 0x0a, 0xaa, 0x86, 0x4c, 0x0d, 0xff, 0x7e, 0x1d, - 0xb4, 0x14, 0xd4, 0x09, 0x91, 0x33, 0x5a, 0xfd, - 0xa0, 0x58, 0x80, 0x9b, 0xbe, 0x78, 0x2e, 0x69, - 0x82, 0x15, 0x7c, 0x72, 0xf0, 0x7b, 0x18, 0x39, - 0xff, 0x6e, 0xeb, 0xc6, 0x86, 0xf5, 0xb4, 0xc7, - 0x6f, 0x02, 0x41, 0x00, 0x8d, 0x1a, 0x37, 0x0f, - 0x76, 0xc4, 0x82, 0xfa, 0x5c, 0xc3, 0x79, 0x35, - 0x3e, 0x70, 0x8a, 0xbf, 0x27, 0x49, 0xb0, 0x99, - 0x63, 0xcb, 0x77, 0x5f, 0xa8, 0x82, 0x65, 0xf6, - 0x03, 0x52, 0x51, 0xf1, 0xae, 0x2e, 0x05, 0xb3, - 0xc6, 0xa4, 0x92, 0xd1, 0xce, 0x6c, 0x72, 0xfb, - 0x21, 0xb3, 0x02, 0x87, 0xe4, 0xfd, 0x61, 0xca, - 0x00, 0x42, 0x19, 0xf0, 0xda, 0x5a, 0x53, 0xe3, - 0xb1, 0xc5, 0x15, 0xf3 -}; +const uint8_t kTestPrivateKeyInfo[] = { + 0x30, 0x82, 0x02, 0x78, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a, + 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82, + 0x02, 0x62, 0x30, 0x82, 0x02, 0x5e, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, + 0x00, 0xb8, 0x7f, 0x2b, 0x20, 0xdc, 0x7c, 0x9b, 0x0c, 0xdc, 0x51, 0x61, + 0x99, 0x0d, 0x36, 0x0f, 0xd4, 0x66, 0x88, 0x08, 0x55, 0x84, 0xd5, 0x3a, + 0xbf, 0x2b, 0xa4, 0x64, 0x85, 0x7b, 0x0c, 0x04, 0x13, 0x3f, 0x8d, 0xf4, + 0xbc, 0x38, 0x0d, 0x49, 0xfe, 0x6b, 0xc4, 0x5a, 0xb0, 0x40, 0x53, 0x3a, + 0xd7, 0x66, 0x09, 0x0f, 0x9e, 0x36, 0x74, 0x30, 0xda, 0x8a, 0x31, 0x4f, + 0x1f, 0x14, 0x50, 0xd7, 0xc7, 0x20, 0x94, 0x17, 0xde, 0x4e, 0xb9, 0x57, + 0x5e, 0x7e, 0x0a, 0xe5, 0xb2, 0x65, 0x7a, 0x89, 0x4e, 0xb6, 0x47, 0xff, + 0x1c, 0xbd, 0xb7, 0x38, 0x13, 0xaf, 0x47, 0x85, 0x84, 0x32, 0x33, 0xf3, + 0x17, 0x49, 0xbf, 0xe9, 0x96, 0xd0, 0xd6, 0x14, 0x6f, 0x13, 0x8d, 0xc5, + 0xfc, 0x2c, 0x72, 0xba, 0xac, 0xea, 0x7e, 0x18, 0x53, 0x56, 0xa6, 0x83, + 0xa2, 0xce, 0x93, 0x93, 0xe7, 0x1f, 0x0f, 0xe6, 0x0f, 0x02, 0x03, 0x01, + 0x00, 0x01, 0x02, 0x81, 0x80, 0x03, 0x61, 0x89, 0x37, 0xcb, 0xf2, 0x98, + 0xa0, 0xce, 0xb4, 0xcb, 0x16, 0x13, 0xf0, 0xe6, 0xaf, 0x5c, 0xc5, 0xa7, + 0x69, 0x71, 0xca, 0xba, 0x8d, 0xe0, 0x4d, 0xdd, 0xed, 0xb8, 0x48, 0x8b, + 0x16, 0x93, 0x36, 0x95, 0xc2, 0x91, 0x40, 0x65, 0x17, 0xbd, 0x7f, 0xd6, + 0xad, 0x9e, 0x30, 0x28, 0x46, 0xe4, 0x3e, 0xcc, 0x43, 0x78, 0xf9, 0xfe, + 0x1f, 0x33, 0x23, 0x1e, 0x31, 0x12, 0x9d, 0x3c, 0xa7, 0x08, 0x82, 0x7b, + 0x7d, 0x25, 0x4e, 0x5e, 0x19, 0xa8, 0x9b, 0xed, 0x86, 0xb2, 0xcb, 0x3c, + 0xfe, 0x4e, 0xa1, 0xfa, 0x62, 0x87, 0x3a, 0x17, 0xf7, 0x60, 0xec, 0x38, + 0x29, 0xe8, 0x4f, 0x34, 0x9f, 0x76, 0x9d, 0xee, 0xa3, 0xf6, 0x85, 0x6b, + 0x84, 0x43, 0xc9, 0x1e, 0x01, 0xff, 0xfd, 0xd0, 0x29, 0x4c, 0xfa, 0x8e, + 0x57, 0x0c, 0xc0, 0x71, 0xa5, 0xbb, 0x88, 0x46, 0x29, 0x5c, 0xc0, 0x4f, + 0x01, 0x02, 0x41, 0x00, 0xf5, 0x83, 0xa4, 0x64, 0x4a, 0xf2, 0xdd, 0x8c, + 0x2c, 0xed, 0xa8, 0xd5, 0x60, 0x5a, 0xe4, 0xc7, 0xcc, 0x61, 0xcd, 0x38, + 0x42, 0x20, 0xd3, 0x82, 0x18, 0xf2, 0x35, 0x00, 0x72, 0x2d, 0xf7, 0x89, + 0x80, 0x67, 0xb5, 0x93, 0x05, 0x5f, 0xdd, 0x42, 0xba, 0x16, 0x1a, 0xea, + 0x15, 0xc6, 0xf0, 0xb8, 0x8c, 0xbc, 0xbf, 0x54, 0x9e, 0xf1, 0xc1, 0xb2, + 0xb3, 0x8b, 0xb6, 0x26, 0x02, 0x30, 0xc4, 0x81, 0x02, 0x41, 0x00, 0xc0, + 0x60, 0x62, 0x80, 0xe1, 0x22, 0x78, 0xf6, 0x9d, 0x83, 0x18, 0xeb, 0x72, + 0x45, 0xd7, 0xc8, 0x01, 0x7f, 0xa9, 0xca, 0x8f, 0x7d, 0xd6, 0xb8, 0x31, + 0x2b, 0x84, 0x7f, 0x62, 0xd9, 0xa9, 0x22, 0x17, 0x7d, 0x06, 0x35, 0x6c, + 0xf3, 0xc1, 0x94, 0x17, 0x85, 0x5a, 0xaf, 0x9c, 0x5c, 0x09, 0x3c, 0xcf, + 0x2f, 0x44, 0x9d, 0xb6, 0x52, 0x68, 0x5f, 0xf9, 0x59, 0xc8, 0x84, 0x2b, + 0x39, 0x22, 0x8f, 0x02, 0x41, 0x00, 0xb2, 0x04, 0xe2, 0x0e, 0x56, 0xca, + 0x03, 0x1a, 0xc0, 0xf9, 0x12, 0x92, 0xa5, 0x6b, 0x42, 0xb8, 0x1c, 0xda, + 0x4d, 0x93, 0x9d, 0x5f, 0x6f, 0xfd, 0xc5, 0x58, 0xda, 0x55, 0x98, 0x74, + 0xfc, 0x28, 0x17, 0x93, 0x1b, 0x75, 0x9f, 0x50, 0x03, 0x7f, 0x7e, 0xae, + 0xc8, 0x95, 0x33, 0x75, 0x2c, 0xd6, 0xa4, 0x35, 0xb8, 0x06, 0x03, 0xba, + 0x08, 0x59, 0x2b, 0x17, 0x02, 0xdc, 0x4c, 0x7a, 0x50, 0x01, 0x02, 0x41, + 0x00, 0x9d, 0xdb, 0x39, 0x59, 0x09, 0xe4, 0x30, 0xa0, 0x24, 0xf5, 0xdb, + 0x2f, 0xf0, 0x2f, 0xf1, 0x75, 0x74, 0x0d, 0x5e, 0xb5, 0x11, 0x73, 0xb0, + 0x0a, 0xaa, 0x86, 0x4c, 0x0d, 0xff, 0x7e, 0x1d, 0xb4, 0x14, 0xd4, 0x09, + 0x91, 0x33, 0x5a, 0xfd, 0xa0, 0x58, 0x80, 0x9b, 0xbe, 0x78, 0x2e, 0x69, + 0x82, 0x15, 0x7c, 0x72, 0xf0, 0x7b, 0x18, 0x39, 0xff, 0x6e, 0xeb, 0xc6, + 0x86, 0xf5, 0xb4, 0xc7, 0x6f, 0x02, 0x41, 0x00, 0x8d, 0x1a, 0x37, 0x0f, + 0x76, 0xc4, 0x82, 0xfa, 0x5c, 0xc3, 0x79, 0x35, 0x3e, 0x70, 0x8a, 0xbf, + 0x27, 0x49, 0xb0, 0x99, 0x63, 0xcb, 0x77, 0x5f, 0xa8, 0x82, 0x65, 0xf6, + 0x03, 0x52, 0x51, 0xf1, 0xae, 0x2e, 0x05, 0xb3, 0xc6, 0xa4, 0x92, 0xd1, + 0xce, 0x6c, 0x72, 0xfb, 0x21, 0xb3, 0x02, 0x87, 0xe4, 0xfd, 0x61, 0xca, + 0x00, 0x42, 0x19, 0xf0, 0xda, 0x5a, 0x53, 0xe3, 0xb1, 0xc5, 0x15, 0xf3}; } // namespace @@ -104,10 +78,10 @@ TEST(RSAPrivateKeyUnitTest, InitRandomTest) { ASSERT_TRUE(keypair1.get()); ASSERT_TRUE(keypair2.get()); - std::vector<uint8> privkey1; - std::vector<uint8> privkey2; - std::vector<uint8> pubkey1; - std::vector<uint8> pubkey2; + std::vector<uint8_t> privkey1; + std::vector<uint8_t> privkey2; + std::vector<uint8_t> pubkey1; + std::vector<uint8_t> pubkey2; ASSERT_TRUE(keypair1->ExportPrivateKey(&privkey1)); ASSERT_TRUE(keypair2->ExportPrivateKey(&privkey2)); @@ -121,8 +95,8 @@ TEST(RSAPrivateKeyUnitTest, InitRandomTest) { ASSERT_TRUE(keypair3.get()); ASSERT_TRUE(keypair4.get()); - std::vector<uint8> privkey3; - std::vector<uint8> privkey4; + std::vector<uint8_t> privkey3; + std::vector<uint8_t> privkey4; ASSERT_TRUE(keypair3->ExportPrivateKey(&privkey3)); ASSERT_TRUE(keypair4->ExportPrivateKey(&privkey4)); @@ -136,8 +110,8 @@ TEST(RSAPrivateKeyUnitTest, InitRandomTest) { // Test Copy() method. TEST(RSAPrivateKeyUnitTest, CopyTest) { - std::vector<uint8> input( - kTestPrivateKeyInfo, kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo)); + std::vector<uint8_t> input(kTestPrivateKeyInfo, + kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo)); scoped_ptr<crypto::RSAPrivateKey> key( crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input)); @@ -145,7 +119,7 @@ TEST(RSAPrivateKeyUnitTest, CopyTest) { scoped_ptr<crypto::RSAPrivateKey> key_copy(key->Copy()); ASSERT_TRUE(key_copy.get()); - std::vector<uint8> privkey_copy; + std::vector<uint8_t> privkey_copy; ASSERT_TRUE(key_copy->ExportPrivateKey(&privkey_copy)); ASSERT_EQ(input, privkey_copy); } @@ -153,8 +127,8 @@ TEST(RSAPrivateKeyUnitTest, CopyTest) { // Test that CreateFromPrivateKeyInfo fails if there is extra data after the RSA // key. TEST(RSAPrivateKeyUnitTest, ExtraData) { - std::vector<uint8> input( - kTestPrivateKeyInfo, kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo)); + std::vector<uint8_t> input(kTestPrivateKeyInfo, + kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo)); input.push_back(0); scoped_ptr<crypto::RSAPrivateKey> key( @@ -166,7 +140,7 @@ TEST(RSAPrivateKeyUnitTest, ExtraData) { TEST(RSAPrivateKeyUnitTest, NotRsaKey) { // Defines a valid P-256 private key. - const uint8 kTestEcPrivateKeyInfo[] = { + const uint8_t kTestEcPrivateKeyInfo[] = { 0x30, 0x81, 0x87, 0x02, 0x01, 0x00, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07, 0x04, 0x6D, 0x30, 0x6B, 0x02, 0x01, 0x01, 0x04, 0x20, @@ -178,10 +152,9 @@ TEST(RSAPrivateKeyUnitTest, NotRsaKey) { 0x8D, 0xC5, 0xAD, 0xA8, 0xE9, 0xA9, 0xDD, 0x7C, 0xB3, 0xC7, 0x0D, 0xF4, 0x48, 0x98, 0x6E, 0x51, 0xBD, 0xE5, 0xD1, 0x57, 0x6F, 0x99, 0x90, 0x1F, 0x9C, 0x2C, 0x6A, 0x80, 0x6A, 0x47, 0xFD, 0x90, 0x76, 0x43, 0xA7, 0x2B, - 0x83, 0x55, 0x97, 0xEF, 0xC8, 0xC6 - }; + 0x83, 0x55, 0x97, 0xEF, 0xC8, 0xC6}; - std::vector<uint8> input( + std::vector<uint8_t> input( kTestEcPrivateKeyInfo, kTestEcPrivateKeyInfo + sizeof(kTestEcPrivateKeyInfo)); @@ -195,38 +168,30 @@ TEST(RSAPrivateKeyUnitTest, NotRsaKey) { // Verify that generated public keys look good. This test data was generated // with the openssl command line tool. TEST(RSAPrivateKeyUnitTest, PublicKeyTest) { - const uint8 expected_public_key_info[] = { - 0x30, 0x81, 0x9f, 0x30, 0x0d, 0x06, 0x09, 0x2a, - 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, - 0x05, 0x00, 0x03, 0x81, 0x8d, 0x00, 0x30, 0x81, - 0x89, 0x02, 0x81, 0x81, 0x00, 0xb8, 0x7f, 0x2b, - 0x20, 0xdc, 0x7c, 0x9b, 0x0c, 0xdc, 0x51, 0x61, - 0x99, 0x0d, 0x36, 0x0f, 0xd4, 0x66, 0x88, 0x08, - 0x55, 0x84, 0xd5, 0x3a, 0xbf, 0x2b, 0xa4, 0x64, - 0x85, 0x7b, 0x0c, 0x04, 0x13, 0x3f, 0x8d, 0xf4, - 0xbc, 0x38, 0x0d, 0x49, 0xfe, 0x6b, 0xc4, 0x5a, - 0xb0, 0x40, 0x53, 0x3a, 0xd7, 0x66, 0x09, 0x0f, - 0x9e, 0x36, 0x74, 0x30, 0xda, 0x8a, 0x31, 0x4f, - 0x1f, 0x14, 0x50, 0xd7, 0xc7, 0x20, 0x94, 0x17, - 0xde, 0x4e, 0xb9, 0x57, 0x5e, 0x7e, 0x0a, 0xe5, - 0xb2, 0x65, 0x7a, 0x89, 0x4e, 0xb6, 0x47, 0xff, - 0x1c, 0xbd, 0xb7, 0x38, 0x13, 0xaf, 0x47, 0x85, - 0x84, 0x32, 0x33, 0xf3, 0x17, 0x49, 0xbf, 0xe9, - 0x96, 0xd0, 0xd6, 0x14, 0x6f, 0x13, 0x8d, 0xc5, - 0xfc, 0x2c, 0x72, 0xba, 0xac, 0xea, 0x7e, 0x18, - 0x53, 0x56, 0xa6, 0x83, 0xa2, 0xce, 0x93, 0x93, - 0xe7, 0x1f, 0x0f, 0xe6, 0x0f, 0x02, 0x03, 0x01, - 0x00, 0x01 - }; - - std::vector<uint8> input( - kTestPrivateKeyInfo, kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo)); + const uint8_t expected_public_key_info[] = { + 0x30, 0x81, 0x9f, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, + 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x81, 0x8d, 0x00, 0x30, 0x81, + 0x89, 0x02, 0x81, 0x81, 0x00, 0xb8, 0x7f, 0x2b, 0x20, 0xdc, 0x7c, 0x9b, + 0x0c, 0xdc, 0x51, 0x61, 0x99, 0x0d, 0x36, 0x0f, 0xd4, 0x66, 0x88, 0x08, + 0x55, 0x84, 0xd5, 0x3a, 0xbf, 0x2b, 0xa4, 0x64, 0x85, 0x7b, 0x0c, 0x04, + 0x13, 0x3f, 0x8d, 0xf4, 0xbc, 0x38, 0x0d, 0x49, 0xfe, 0x6b, 0xc4, 0x5a, + 0xb0, 0x40, 0x53, 0x3a, 0xd7, 0x66, 0x09, 0x0f, 0x9e, 0x36, 0x74, 0x30, + 0xda, 0x8a, 0x31, 0x4f, 0x1f, 0x14, 0x50, 0xd7, 0xc7, 0x20, 0x94, 0x17, + 0xde, 0x4e, 0xb9, 0x57, 0x5e, 0x7e, 0x0a, 0xe5, 0xb2, 0x65, 0x7a, 0x89, + 0x4e, 0xb6, 0x47, 0xff, 0x1c, 0xbd, 0xb7, 0x38, 0x13, 0xaf, 0x47, 0x85, + 0x84, 0x32, 0x33, 0xf3, 0x17, 0x49, 0xbf, 0xe9, 0x96, 0xd0, 0xd6, 0x14, + 0x6f, 0x13, 0x8d, 0xc5, 0xfc, 0x2c, 0x72, 0xba, 0xac, 0xea, 0x7e, 0x18, + 0x53, 0x56, 0xa6, 0x83, 0xa2, 0xce, 0x93, 0x93, 0xe7, 0x1f, 0x0f, 0xe6, + 0x0f, 0x02, 0x03, 0x01, 0x00, 0x01}; + + std::vector<uint8_t> input(kTestPrivateKeyInfo, + kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo)); scoped_ptr<crypto::RSAPrivateKey> key( crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input)); ASSERT_TRUE(key.get()); - std::vector<uint8> output; + std::vector<uint8_t> output; ASSERT_TRUE(key->ExportPublicKey(&output)); ASSERT_TRUE( @@ -248,174 +213,118 @@ TEST(RSAPrivateKeyUnitTest, PublicKeyTest) { // // This test case verifies these two failures modes don't occur. TEST(RSAPrivateKeyUnitTest, ShortIntegers) { - const uint8 short_integer_with_high_bit[] = { - 0x30, 0x82, 0x02, 0x77, 0x02, 0x01, 0x00, 0x30, - 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, - 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82, - 0x02, 0x61, 0x30, 0x82, 0x02, 0x5d, 0x02, 0x01, - 0x00, 0x02, 0x81, 0x81, 0x00, 0x92, 0x59, 0x32, - 0x7d, 0x8e, 0xaf, 0x2e, 0xd5, 0xb2, 0x5c, 0x67, - 0xc8, 0x7d, 0x48, 0xb7, 0x84, 0x12, 0xd0, 0x76, - 0xda, 0xe1, 0xa3, 0x1e, 0x40, 0x01, 0x14, 0x5c, - 0xef, 0x26, 0x6e, 0x28, 0xa2, 0xf7, 0xa5, 0xb4, - 0x02, 0x37, 0xd0, 0x53, 0x10, 0xcb, 0x7c, 0x6a, - 0xf4, 0x53, 0x9f, 0xb8, 0xe0, 0x83, 0x93, 0xd1, - 0x19, 0xd8, 0x28, 0xd1, 0xd1, 0xd8, 0x87, 0x8f, - 0x92, 0xfd, 0x73, 0xc0, 0x4d, 0x3e, 0x07, 0x22, - 0x1f, 0xc1, 0x20, 0xb0, 0x70, 0xb2, 0x3b, 0xea, - 0xb1, 0xe5, 0x0a, 0xfd, 0x56, 0x49, 0x5e, 0x39, - 0x90, 0x91, 0xce, 0x04, 0x83, 0x29, 0xaa, 0xfd, - 0x12, 0xa4, 0x42, 0x26, 0x6c, 0x6e, 0x79, 0x70, - 0x77, 0x03, 0xb2, 0x07, 0x01, 0x3d, 0x85, 0x81, - 0x95, 0x9e, 0xda, 0x5a, 0xa3, 0xf4, 0x2d, 0x38, - 0x04, 0x58, 0xf5, 0x6b, 0xc9, 0xf1, 0xb5, 0x65, - 0xfe, 0x66, 0x0d, 0xa2, 0xd5, 0x02, 0x03, 0x01, - 0x00, 0x01, 0x02, 0x81, 0x80, 0x5e, 0x01, 0x5f, - 0xb6, 0x59, 0x1d, 0xdc, 0x36, 0xb6, 0x60, 0x36, - 0xe6, 0x08, 0xdb, 0xd9, 0xcd, 0xc3, 0x8c, 0x16, - 0x9c, 0x98, 0x8d, 0x7f, 0xd3, 0xdb, 0x1d, 0xaa, - 0x68, 0x8f, 0xc5, 0xf8, 0xe2, 0x5d, 0xb3, 0x19, - 0xc2, 0xc6, 0xf9, 0x51, 0x32, 0x1b, 0x93, 0x6a, - 0xdc, 0x50, 0x8e, 0xeb, 0x61, 0x84, 0x03, 0x42, - 0x30, 0x98, 0xb1, 0xf7, 0xbd, 0x14, 0x9a, 0x57, - 0x36, 0x33, 0x09, 0xd4, 0x3e, 0x90, 0xda, 0xef, - 0x09, 0x6e, 0xef, 0x49, 0xb6, 0x60, 0x68, 0x5e, - 0x54, 0x17, 0x25, 0x5b, 0x37, 0xe3, 0x35, 0x63, - 0x5b, 0x60, 0x3c, 0xbd, 0x50, 0xdf, 0x46, 0x43, - 0x08, 0xa4, 0x71, 0x21, 0xf1, 0x30, 0x71, 0xdc, - 0xda, 0xd7, 0x6f, 0xd2, 0x18, 0xbd, 0x39, 0xf1, - 0xe1, 0xbe, 0xa8, 0x8d, 0x62, 0xdf, 0xa2, 0x3e, - 0xb6, 0x15, 0x26, 0xb6, 0x57, 0xbd, 0x63, 0xdb, - 0xc1, 0x91, 0xec, 0xb8, 0x01, 0x02, 0x41, 0x00, - 0xc6, 0x1a, 0x06, 0x48, 0xf2, 0x12, 0x1c, 0x9f, - 0x74, 0x20, 0x5c, 0x85, 0xa2, 0xda, 0xe5, 0x62, - 0x96, 0x8d, 0x22, 0x7b, 0x78, 0x73, 0xea, 0xbb, - 0x9f, 0x59, 0x42, 0x13, 0x15, 0xc8, 0x11, 0x50, - 0x6c, 0x55, 0xf6, 0xdf, 0x8b, 0xfe, 0xc7, 0xdd, - 0xa8, 0xca, 0x54, 0x41, 0xe8, 0xce, 0xbe, 0x7d, - 0xbd, 0xe2, 0x13, 0x4b, 0x5b, 0x61, 0xeb, 0x69, - 0x6c, 0xb1, 0x9b, 0x28, 0x68, 0x5b, 0xd6, 0x01, - 0x02, 0x41, 0x00, 0xbd, 0x1e, 0xfe, 0x51, 0x99, - 0xb6, 0xe3, 0x84, 0xfe, 0xf1, 0x9e, 0xfd, 0x9c, - 0xe7, 0x86, 0x43, 0x68, 0x7f, 0x2f, 0x6a, 0x2a, - 0x4c, 0xae, 0xa6, 0x41, 0x1c, 0xf0, 0x10, 0x37, - 0x54, 0x23, 0xba, 0x05, 0x0d, 0x18, 0x27, 0x8d, - 0xb8, 0xe4, 0x8f, 0xf2, 0x25, 0x73, 0x8a, 0xd7, - 0x05, 0x98, 0x6b, 0x3d, 0x55, 0xb7, 0x6f, 0x7c, - 0xec, 0x77, 0x61, 0x54, 0x7b, 0xb6, 0x6b, 0x31, - 0xec, 0x94, 0xd5, 0x02, 0x41, 0x00, 0x90, 0xa2, - 0xa5, 0x9e, 0x12, 0xa7, 0x68, 0xa0, 0x7e, 0xdf, - 0xb5, 0xcd, 0x98, 0x26, 0xab, 0xbd, 0xbc, 0x5f, - 0xd5, 0x22, 0x42, 0xc2, 0x97, 0x4a, 0x5f, 0x40, - 0x82, 0xfe, 0x7e, 0x33, 0xb1, 0x78, 0x7f, 0x70, - 0x90, 0x2b, 0x8d, 0x01, 0xfb, 0x18, 0xfa, 0x48, - 0xa7, 0x15, 0xec, 0x0d, 0x2e, 0x85, 0x8d, 0xe2, - 0x86, 0xe5, 0xc9, 0x15, 0x88, 0x14, 0x53, 0xd8, - 0xa4, 0x88, 0xef, 0x10, 0xc6, 0x01, 0x02, 0x41, - 0x00, 0xba, 0xe4, 0xaf, 0x14, 0xfa, 0xdf, 0xf6, - 0xd5, 0xce, 0x8f, 0xfe, 0xbb, 0xc8, 0x5c, 0x30, - 0x9d, 0xda, 0xdd, 0x9d, 0x80, 0xc0, 0x0e, 0x89, - 0xa5, 0xb8, 0xc1, 0x1d, 0x28, 0x19, 0x55, 0x67, - 0xfd, 0x03, 0xd2, 0xdd, 0xe4, 0xf0, 0xb4, 0x20, - 0x03, 0x74, 0x9b, 0xb8, 0x24, 0x23, 0xbb, 0xde, - 0xd5, 0x53, 0x86, 0xaa, 0xc1, 0x5d, 0x65, 0xdd, - 0xcf, 0xec, 0x8a, 0x59, 0x4a, 0x73, 0xca, 0xc5, - 0x85, 0x02, 0x40, 0x00, 0xc4, 0x5e, 0x8d, 0xa4, - 0xea, 0xbb, 0x6a, 0x9b, 0xe6, 0x3a, 0x4d, 0xc1, - 0xdb, 0xe5, 0x52, 0x38, 0xf9, 0x59, 0x91, 0x2d, - 0x90, 0x82, 0xe3, 0x31, 0x1b, 0x48, 0xb7, 0x42, - 0xfa, 0x1d, 0x83, 0xd5, 0x3d, 0x02, 0xc2, 0x12, - 0x71, 0x10, 0x3a, 0xbd, 0x92, 0x8f, 0x9b, 0xa2, - 0x6b, 0x2d, 0x21, 0xa4, 0x65, 0xe9, 0xfa, 0x8c, - 0x30, 0x2a, 0x89, 0xce, 0xd0, 0xa7, 0x67, 0xd8, - 0x45, 0x84, 0xb0 - }; - - const uint8 short_integer_without_high_bit[] = { - 0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, - 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, - 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82, - 0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, - 0x00, 0x02, 0x81, 0x81, 0x00, 0xc3, 0x9e, 0x8d, - 0xc4, 0x6d, 0x38, 0xe8, 0x0e, 0x9f, 0x84, 0x03, - 0x40, 0x8e, 0x81, 0x2e, 0x56, 0x67, 0x78, 0x11, - 0x85, 0x27, 0x81, 0x52, 0xf2, 0x1b, 0x3e, 0x5b, - 0xf8, 0xab, 0xfc, 0xaf, 0xca, 0x5c, 0x26, 0xd5, - 0xfa, 0xd4, 0x55, 0x50, 0x38, 0xb9, 0x9d, 0x89, - 0x92, 0x7e, 0x34, 0xcf, 0x37, 0x82, 0x48, 0x2d, - 0xaa, 0xc4, 0x6a, 0x0e, 0x93, 0xea, 0xad, 0x8a, - 0x33, 0xf0, 0x42, 0x23, 0xe0, 0x4c, 0x98, 0xbf, - 0x01, 0x00, 0x1b, 0xfe, 0x06, 0x15, 0xc6, 0xe3, - 0x80, 0x79, 0x6d, 0xfe, 0x48, 0xcd, 0x40, 0xbb, - 0xf9, 0x58, 0xe6, 0xbf, 0xd5, 0x4c, 0x29, 0x48, - 0x53, 0x78, 0x06, 0x03, 0x0d, 0x59, 0xf5, 0x20, - 0xe0, 0xe6, 0x8c, 0xb2, 0xf5, 0xd8, 0x61, 0x52, - 0x7e, 0x40, 0x83, 0xd7, 0x69, 0xae, 0xd7, 0x75, - 0x02, 0x2d, 0x49, 0xd5, 0x15, 0x5b, 0xf1, 0xd9, - 0x4d, 0x60, 0x7d, 0x62, 0xa5, 0x02, 0x03, 0x01, - 0x00, 0x01, 0x02, 0x7f, 0x6d, 0x45, 0x23, 0xeb, - 0x95, 0x17, 0x34, 0x88, 0xf6, 0x91, 0xc7, 0x3f, - 0x48, 0x5a, 0xe0, 0x87, 0x63, 0x44, 0xae, 0x84, - 0xb2, 0x8c, 0x8a, 0xc8, 0xb2, 0x6f, 0x22, 0xf0, - 0xc5, 0x21, 0x61, 0x10, 0xa8, 0x69, 0x09, 0x1e, - 0x13, 0x7d, 0x94, 0x52, 0x1b, 0x5c, 0xe4, 0x7b, - 0xf0, 0x03, 0x8f, 0xbc, 0x72, 0x09, 0xdf, 0x78, - 0x84, 0x3e, 0xb9, 0xe5, 0xe6, 0x31, 0x0a, 0x01, - 0xf9, 0x32, 0xf8, 0xd6, 0x57, 0xa3, 0x87, 0xe6, - 0xf5, 0x98, 0xbc, 0x8e, 0x41, 0xb9, 0x50, 0x17, - 0x7b, 0xd3, 0x97, 0x5a, 0x44, 0x3a, 0xee, 0xff, - 0x6b, 0xb3, 0x3a, 0x52, 0xe7, 0xa4, 0x96, 0x9a, - 0xf6, 0x83, 0xc8, 0x97, 0x1c, 0x63, 0xa1, 0xd6, - 0xb3, 0xa8, 0xb2, 0xc7, 0x73, 0x25, 0x0f, 0x58, - 0x36, 0xb9, 0x7a, 0x47, 0xa7, 0x4d, 0x30, 0xfe, - 0x4d, 0x74, 0x56, 0xe8, 0xfb, 0xd6, 0x50, 0xe5, - 0xe0, 0x28, 0x15, 0x02, 0x41, 0x00, 0xeb, 0x15, - 0x62, 0xb6, 0x37, 0x41, 0x7c, 0xc5, 0x00, 0x22, - 0x2c, 0x5a, 0x5e, 0xe4, 0xb2, 0x11, 0x87, 0x89, - 0xad, 0xf4, 0x57, 0x68, 0x90, 0xb7, 0x9f, 0xe2, - 0x79, 0x20, 0x6b, 0x98, 0x00, 0x0d, 0x3a, 0x3b, - 0xc1, 0xcd, 0x36, 0xf9, 0x27, 0xda, 0x40, 0x36, - 0x1d, 0xb8, 0x5c, 0x96, 0xeb, 0x04, 0x08, 0xe1, - 0x3f, 0xfa, 0x94, 0x8b, 0x0f, 0xa0, 0xff, 0xc1, - 0x51, 0xea, 0x90, 0xad, 0x15, 0xc7, 0x02, 0x41, - 0x00, 0xd5, 0x06, 0x45, 0xd7, 0x55, 0x63, 0x1a, - 0xf0, 0x89, 0x81, 0xae, 0x87, 0x23, 0xa2, 0x39, - 0xfe, 0x3d, 0x82, 0xc7, 0xcb, 0x15, 0xb9, 0xe3, - 0xe2, 0x5b, 0xc6, 0xd2, 0x55, 0xdd, 0xab, 0x55, - 0x29, 0x7c, 0xda, 0x0e, 0x1c, 0x09, 0xfc, 0x73, - 0x0d, 0x01, 0xed, 0x6d, 0x2f, 0x05, 0xd0, 0xd5, - 0x1d, 0xce, 0x18, 0x7f, 0xb0, 0xc8, 0x47, 0x77, - 0xd2, 0xa9, 0x9e, 0xfc, 0x39, 0x4b, 0x3d, 0x94, - 0x33, 0x02, 0x41, 0x00, 0x8f, 0x94, 0x09, 0x2d, - 0x17, 0x44, 0x75, 0x0a, 0xf1, 0x10, 0xee, 0x1b, - 0xe7, 0xd7, 0x2f, 0xf6, 0xca, 0xdc, 0x49, 0x15, - 0x72, 0x09, 0x58, 0x51, 0xfe, 0x61, 0xd8, 0xee, - 0xf7, 0x27, 0xe7, 0xe8, 0x2c, 0x47, 0xf1, 0x0f, - 0x00, 0x63, 0x5e, 0x76, 0xcb, 0x3f, 0x02, 0x19, - 0xe6, 0xda, 0xfa, 0x01, 0x05, 0xd7, 0x65, 0x37, - 0x0b, 0x60, 0x7f, 0x94, 0x2a, 0x80, 0x8d, 0x22, - 0x81, 0x68, 0x65, 0x63, 0x02, 0x41, 0x00, 0xc2, - 0xd4, 0x18, 0xde, 0x47, 0x9e, 0xfb, 0x8d, 0x91, - 0x05, 0xc5, 0x3c, 0x9d, 0xcf, 0x8a, 0x60, 0xc7, - 0x9b, 0x2b, 0xe5, 0xc6, 0xba, 0x1b, 0xfc, 0xf3, - 0xd9, 0x54, 0x97, 0xe9, 0xc4, 0x00, 0x80, 0x90, - 0x4a, 0xd2, 0x6a, 0xbc, 0x8b, 0x62, 0x22, 0x3c, - 0x68, 0x0c, 0xda, 0xdb, 0xe3, 0xd2, 0x76, 0x8e, - 0xff, 0x03, 0x12, 0x09, 0x2a, 0xac, 0x21, 0x44, - 0xb7, 0x3e, 0x91, 0x9c, 0x09, 0xf6, 0xd7, 0x02, - 0x41, 0x00, 0xc0, 0xa1, 0xbb, 0x70, 0xdc, 0xf8, - 0xeb, 0x17, 0x61, 0xd4, 0x8c, 0x7c, 0x3b, 0x82, - 0x91, 0x58, 0xff, 0xf9, 0x19, 0xac, 0x3a, 0x73, - 0xa7, 0x20, 0xe5, 0x22, 0x02, 0xc4, 0xf6, 0xb9, - 0xb9, 0x43, 0x53, 0x35, 0x88, 0xe1, 0x05, 0xb6, - 0x43, 0x9b, 0x39, 0xc8, 0x04, 0x4d, 0x2b, 0x01, - 0xf7, 0xe6, 0x1b, 0x8d, 0x7e, 0x89, 0xe3, 0x43, - 0xd4, 0xf3, 0xab, 0x28, 0xd4, 0x5a, 0x1f, 0x20, - 0xea, 0xbe - }; - - std::vector<uint8> input1; - std::vector<uint8> input2; + const uint8_t short_integer_with_high_bit[] = { + 0x30, 0x82, 0x02, 0x77, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a, + 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82, + 0x02, 0x61, 0x30, 0x82, 0x02, 0x5d, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, + 0x00, 0x92, 0x59, 0x32, 0x7d, 0x8e, 0xaf, 0x2e, 0xd5, 0xb2, 0x5c, 0x67, + 0xc8, 0x7d, 0x48, 0xb7, 0x84, 0x12, 0xd0, 0x76, 0xda, 0xe1, 0xa3, 0x1e, + 0x40, 0x01, 0x14, 0x5c, 0xef, 0x26, 0x6e, 0x28, 0xa2, 0xf7, 0xa5, 0xb4, + 0x02, 0x37, 0xd0, 0x53, 0x10, 0xcb, 0x7c, 0x6a, 0xf4, 0x53, 0x9f, 0xb8, + 0xe0, 0x83, 0x93, 0xd1, 0x19, 0xd8, 0x28, 0xd1, 0xd1, 0xd8, 0x87, 0x8f, + 0x92, 0xfd, 0x73, 0xc0, 0x4d, 0x3e, 0x07, 0x22, 0x1f, 0xc1, 0x20, 0xb0, + 0x70, 0xb2, 0x3b, 0xea, 0xb1, 0xe5, 0x0a, 0xfd, 0x56, 0x49, 0x5e, 0x39, + 0x90, 0x91, 0xce, 0x04, 0x83, 0x29, 0xaa, 0xfd, 0x12, 0xa4, 0x42, 0x26, + 0x6c, 0x6e, 0x79, 0x70, 0x77, 0x03, 0xb2, 0x07, 0x01, 0x3d, 0x85, 0x81, + 0x95, 0x9e, 0xda, 0x5a, 0xa3, 0xf4, 0x2d, 0x38, 0x04, 0x58, 0xf5, 0x6b, + 0xc9, 0xf1, 0xb5, 0x65, 0xfe, 0x66, 0x0d, 0xa2, 0xd5, 0x02, 0x03, 0x01, + 0x00, 0x01, 0x02, 0x81, 0x80, 0x5e, 0x01, 0x5f, 0xb6, 0x59, 0x1d, 0xdc, + 0x36, 0xb6, 0x60, 0x36, 0xe6, 0x08, 0xdb, 0xd9, 0xcd, 0xc3, 0x8c, 0x16, + 0x9c, 0x98, 0x8d, 0x7f, 0xd3, 0xdb, 0x1d, 0xaa, 0x68, 0x8f, 0xc5, 0xf8, + 0xe2, 0x5d, 0xb3, 0x19, 0xc2, 0xc6, 0xf9, 0x51, 0x32, 0x1b, 0x93, 0x6a, + 0xdc, 0x50, 0x8e, 0xeb, 0x61, 0x84, 0x03, 0x42, 0x30, 0x98, 0xb1, 0xf7, + 0xbd, 0x14, 0x9a, 0x57, 0x36, 0x33, 0x09, 0xd4, 0x3e, 0x90, 0xda, 0xef, + 0x09, 0x6e, 0xef, 0x49, 0xb6, 0x60, 0x68, 0x5e, 0x54, 0x17, 0x25, 0x5b, + 0x37, 0xe3, 0x35, 0x63, 0x5b, 0x60, 0x3c, 0xbd, 0x50, 0xdf, 0x46, 0x43, + 0x08, 0xa4, 0x71, 0x21, 0xf1, 0x30, 0x71, 0xdc, 0xda, 0xd7, 0x6f, 0xd2, + 0x18, 0xbd, 0x39, 0xf1, 0xe1, 0xbe, 0xa8, 0x8d, 0x62, 0xdf, 0xa2, 0x3e, + 0xb6, 0x15, 0x26, 0xb6, 0x57, 0xbd, 0x63, 0xdb, 0xc1, 0x91, 0xec, 0xb8, + 0x01, 0x02, 0x41, 0x00, 0xc6, 0x1a, 0x06, 0x48, 0xf2, 0x12, 0x1c, 0x9f, + 0x74, 0x20, 0x5c, 0x85, 0xa2, 0xda, 0xe5, 0x62, 0x96, 0x8d, 0x22, 0x7b, + 0x78, 0x73, 0xea, 0xbb, 0x9f, 0x59, 0x42, 0x13, 0x15, 0xc8, 0x11, 0x50, + 0x6c, 0x55, 0xf6, 0xdf, 0x8b, 0xfe, 0xc7, 0xdd, 0xa8, 0xca, 0x54, 0x41, + 0xe8, 0xce, 0xbe, 0x7d, 0xbd, 0xe2, 0x13, 0x4b, 0x5b, 0x61, 0xeb, 0x69, + 0x6c, 0xb1, 0x9b, 0x28, 0x68, 0x5b, 0xd6, 0x01, 0x02, 0x41, 0x00, 0xbd, + 0x1e, 0xfe, 0x51, 0x99, 0xb6, 0xe3, 0x84, 0xfe, 0xf1, 0x9e, 0xfd, 0x9c, + 0xe7, 0x86, 0x43, 0x68, 0x7f, 0x2f, 0x6a, 0x2a, 0x4c, 0xae, 0xa6, 0x41, + 0x1c, 0xf0, 0x10, 0x37, 0x54, 0x23, 0xba, 0x05, 0x0d, 0x18, 0x27, 0x8d, + 0xb8, 0xe4, 0x8f, 0xf2, 0x25, 0x73, 0x8a, 0xd7, 0x05, 0x98, 0x6b, 0x3d, + 0x55, 0xb7, 0x6f, 0x7c, 0xec, 0x77, 0x61, 0x54, 0x7b, 0xb6, 0x6b, 0x31, + 0xec, 0x94, 0xd5, 0x02, 0x41, 0x00, 0x90, 0xa2, 0xa5, 0x9e, 0x12, 0xa7, + 0x68, 0xa0, 0x7e, 0xdf, 0xb5, 0xcd, 0x98, 0x26, 0xab, 0xbd, 0xbc, 0x5f, + 0xd5, 0x22, 0x42, 0xc2, 0x97, 0x4a, 0x5f, 0x40, 0x82, 0xfe, 0x7e, 0x33, + 0xb1, 0x78, 0x7f, 0x70, 0x90, 0x2b, 0x8d, 0x01, 0xfb, 0x18, 0xfa, 0x48, + 0xa7, 0x15, 0xec, 0x0d, 0x2e, 0x85, 0x8d, 0xe2, 0x86, 0xe5, 0xc9, 0x15, + 0x88, 0x14, 0x53, 0xd8, 0xa4, 0x88, 0xef, 0x10, 0xc6, 0x01, 0x02, 0x41, + 0x00, 0xba, 0xe4, 0xaf, 0x14, 0xfa, 0xdf, 0xf6, 0xd5, 0xce, 0x8f, 0xfe, + 0xbb, 0xc8, 0x5c, 0x30, 0x9d, 0xda, 0xdd, 0x9d, 0x80, 0xc0, 0x0e, 0x89, + 0xa5, 0xb8, 0xc1, 0x1d, 0x28, 0x19, 0x55, 0x67, 0xfd, 0x03, 0xd2, 0xdd, + 0xe4, 0xf0, 0xb4, 0x20, 0x03, 0x74, 0x9b, 0xb8, 0x24, 0x23, 0xbb, 0xde, + 0xd5, 0x53, 0x86, 0xaa, 0xc1, 0x5d, 0x65, 0xdd, 0xcf, 0xec, 0x8a, 0x59, + 0x4a, 0x73, 0xca, 0xc5, 0x85, 0x02, 0x40, 0x00, 0xc4, 0x5e, 0x8d, 0xa4, + 0xea, 0xbb, 0x6a, 0x9b, 0xe6, 0x3a, 0x4d, 0xc1, 0xdb, 0xe5, 0x52, 0x38, + 0xf9, 0x59, 0x91, 0x2d, 0x90, 0x82, 0xe3, 0x31, 0x1b, 0x48, 0xb7, 0x42, + 0xfa, 0x1d, 0x83, 0xd5, 0x3d, 0x02, 0xc2, 0x12, 0x71, 0x10, 0x3a, 0xbd, + 0x92, 0x8f, 0x9b, 0xa2, 0x6b, 0x2d, 0x21, 0xa4, 0x65, 0xe9, 0xfa, 0x8c, + 0x30, 0x2a, 0x89, 0xce, 0xd0, 0xa7, 0x67, 0xd8, 0x45, 0x84, 0xb0}; + + const uint8_t short_integer_without_high_bit[] = { + 0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a, + 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82, + 0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, + 0x00, 0xc3, 0x9e, 0x8d, 0xc4, 0x6d, 0x38, 0xe8, 0x0e, 0x9f, 0x84, 0x03, + 0x40, 0x8e, 0x81, 0x2e, 0x56, 0x67, 0x78, 0x11, 0x85, 0x27, 0x81, 0x52, + 0xf2, 0x1b, 0x3e, 0x5b, 0xf8, 0xab, 0xfc, 0xaf, 0xca, 0x5c, 0x26, 0xd5, + 0xfa, 0xd4, 0x55, 0x50, 0x38, 0xb9, 0x9d, 0x89, 0x92, 0x7e, 0x34, 0xcf, + 0x37, 0x82, 0x48, 0x2d, 0xaa, 0xc4, 0x6a, 0x0e, 0x93, 0xea, 0xad, 0x8a, + 0x33, 0xf0, 0x42, 0x23, 0xe0, 0x4c, 0x98, 0xbf, 0x01, 0x00, 0x1b, 0xfe, + 0x06, 0x15, 0xc6, 0xe3, 0x80, 0x79, 0x6d, 0xfe, 0x48, 0xcd, 0x40, 0xbb, + 0xf9, 0x58, 0xe6, 0xbf, 0xd5, 0x4c, 0x29, 0x48, 0x53, 0x78, 0x06, 0x03, + 0x0d, 0x59, 0xf5, 0x20, 0xe0, 0xe6, 0x8c, 0xb2, 0xf5, 0xd8, 0x61, 0x52, + 0x7e, 0x40, 0x83, 0xd7, 0x69, 0xae, 0xd7, 0x75, 0x02, 0x2d, 0x49, 0xd5, + 0x15, 0x5b, 0xf1, 0xd9, 0x4d, 0x60, 0x7d, 0x62, 0xa5, 0x02, 0x03, 0x01, + 0x00, 0x01, 0x02, 0x7f, 0x6d, 0x45, 0x23, 0xeb, 0x95, 0x17, 0x34, 0x88, + 0xf6, 0x91, 0xc7, 0x3f, 0x48, 0x5a, 0xe0, 0x87, 0x63, 0x44, 0xae, 0x84, + 0xb2, 0x8c, 0x8a, 0xc8, 0xb2, 0x6f, 0x22, 0xf0, 0xc5, 0x21, 0x61, 0x10, + 0xa8, 0x69, 0x09, 0x1e, 0x13, 0x7d, 0x94, 0x52, 0x1b, 0x5c, 0xe4, 0x7b, + 0xf0, 0x03, 0x8f, 0xbc, 0x72, 0x09, 0xdf, 0x78, 0x84, 0x3e, 0xb9, 0xe5, + 0xe6, 0x31, 0x0a, 0x01, 0xf9, 0x32, 0xf8, 0xd6, 0x57, 0xa3, 0x87, 0xe6, + 0xf5, 0x98, 0xbc, 0x8e, 0x41, 0xb9, 0x50, 0x17, 0x7b, 0xd3, 0x97, 0x5a, + 0x44, 0x3a, 0xee, 0xff, 0x6b, 0xb3, 0x3a, 0x52, 0xe7, 0xa4, 0x96, 0x9a, + 0xf6, 0x83, 0xc8, 0x97, 0x1c, 0x63, 0xa1, 0xd6, 0xb3, 0xa8, 0xb2, 0xc7, + 0x73, 0x25, 0x0f, 0x58, 0x36, 0xb9, 0x7a, 0x47, 0xa7, 0x4d, 0x30, 0xfe, + 0x4d, 0x74, 0x56, 0xe8, 0xfb, 0xd6, 0x50, 0xe5, 0xe0, 0x28, 0x15, 0x02, + 0x41, 0x00, 0xeb, 0x15, 0x62, 0xb6, 0x37, 0x41, 0x7c, 0xc5, 0x00, 0x22, + 0x2c, 0x5a, 0x5e, 0xe4, 0xb2, 0x11, 0x87, 0x89, 0xad, 0xf4, 0x57, 0x68, + 0x90, 0xb7, 0x9f, 0xe2, 0x79, 0x20, 0x6b, 0x98, 0x00, 0x0d, 0x3a, 0x3b, + 0xc1, 0xcd, 0x36, 0xf9, 0x27, 0xda, 0x40, 0x36, 0x1d, 0xb8, 0x5c, 0x96, + 0xeb, 0x04, 0x08, 0xe1, 0x3f, 0xfa, 0x94, 0x8b, 0x0f, 0xa0, 0xff, 0xc1, + 0x51, 0xea, 0x90, 0xad, 0x15, 0xc7, 0x02, 0x41, 0x00, 0xd5, 0x06, 0x45, + 0xd7, 0x55, 0x63, 0x1a, 0xf0, 0x89, 0x81, 0xae, 0x87, 0x23, 0xa2, 0x39, + 0xfe, 0x3d, 0x82, 0xc7, 0xcb, 0x15, 0xb9, 0xe3, 0xe2, 0x5b, 0xc6, 0xd2, + 0x55, 0xdd, 0xab, 0x55, 0x29, 0x7c, 0xda, 0x0e, 0x1c, 0x09, 0xfc, 0x73, + 0x0d, 0x01, 0xed, 0x6d, 0x2f, 0x05, 0xd0, 0xd5, 0x1d, 0xce, 0x18, 0x7f, + 0xb0, 0xc8, 0x47, 0x77, 0xd2, 0xa9, 0x9e, 0xfc, 0x39, 0x4b, 0x3d, 0x94, + 0x33, 0x02, 0x41, 0x00, 0x8f, 0x94, 0x09, 0x2d, 0x17, 0x44, 0x75, 0x0a, + 0xf1, 0x10, 0xee, 0x1b, 0xe7, 0xd7, 0x2f, 0xf6, 0xca, 0xdc, 0x49, 0x15, + 0x72, 0x09, 0x58, 0x51, 0xfe, 0x61, 0xd8, 0xee, 0xf7, 0x27, 0xe7, 0xe8, + 0x2c, 0x47, 0xf1, 0x0f, 0x00, 0x63, 0x5e, 0x76, 0xcb, 0x3f, 0x02, 0x19, + 0xe6, 0xda, 0xfa, 0x01, 0x05, 0xd7, 0x65, 0x37, 0x0b, 0x60, 0x7f, 0x94, + 0x2a, 0x80, 0x8d, 0x22, 0x81, 0x68, 0x65, 0x63, 0x02, 0x41, 0x00, 0xc2, + 0xd4, 0x18, 0xde, 0x47, 0x9e, 0xfb, 0x8d, 0x91, 0x05, 0xc5, 0x3c, 0x9d, + 0xcf, 0x8a, 0x60, 0xc7, 0x9b, 0x2b, 0xe5, 0xc6, 0xba, 0x1b, 0xfc, 0xf3, + 0xd9, 0x54, 0x97, 0xe9, 0xc4, 0x00, 0x80, 0x90, 0x4a, 0xd2, 0x6a, 0xbc, + 0x8b, 0x62, 0x22, 0x3c, 0x68, 0x0c, 0xda, 0xdb, 0xe3, 0xd2, 0x76, 0x8e, + 0xff, 0x03, 0x12, 0x09, 0x2a, 0xac, 0x21, 0x44, 0xb7, 0x3e, 0x91, 0x9c, + 0x09, 0xf6, 0xd7, 0x02, 0x41, 0x00, 0xc0, 0xa1, 0xbb, 0x70, 0xdc, 0xf8, + 0xeb, 0x17, 0x61, 0xd4, 0x8c, 0x7c, 0x3b, 0x82, 0x91, 0x58, 0xff, 0xf9, + 0x19, 0xac, 0x3a, 0x73, 0xa7, 0x20, 0xe5, 0x22, 0x02, 0xc4, 0xf6, 0xb9, + 0xb9, 0x43, 0x53, 0x35, 0x88, 0xe1, 0x05, 0xb6, 0x43, 0x9b, 0x39, 0xc8, + 0x04, 0x4d, 0x2b, 0x01, 0xf7, 0xe6, 0x1b, 0x8d, 0x7e, 0x89, 0xe3, 0x43, + 0xd4, 0xf3, 0xab, 0x28, 0xd4, 0x5a, 0x1f, 0x20, 0xea, 0xbe}; + + std::vector<uint8_t> input1; + std::vector<uint8_t> input2; input1.resize(sizeof(short_integer_with_high_bit)); input2.resize(sizeof(short_integer_without_high_bit)); @@ -432,8 +341,8 @@ TEST(RSAPrivateKeyUnitTest, ShortIntegers) { ASSERT_TRUE(keypair1.get()); ASSERT_TRUE(keypair2.get()); - std::vector<uint8> output1; - std::vector<uint8> output2; + std::vector<uint8_t> output1; + std::vector<uint8_t> output2; ASSERT_TRUE(keypair1->ExportPrivateKey(&output1)); ASSERT_TRUE(keypair2->ExportPrivateKey(&output2)); @@ -454,13 +363,13 @@ TEST(RSAPrivateKeyUnitTest, CreateFromKeyTest) { crypto::RSAPrivateKey::CreateFromKey(key_pair->key())); ASSERT_TRUE(key_copy.get()); - std::vector<uint8> privkey; - std::vector<uint8> pubkey; + std::vector<uint8_t> privkey; + std::vector<uint8_t> pubkey; ASSERT_TRUE(key_pair->ExportPrivateKey(&privkey)); ASSERT_TRUE(key_pair->ExportPublicKey(&pubkey)); - std::vector<uint8> privkey_copy; - std::vector<uint8> pubkey_copy; + std::vector<uint8_t> privkey_copy; + std::vector<uint8_t> pubkey_copy; ASSERT_TRUE(key_copy->ExportPrivateKey(&privkey_copy)); ASSERT_TRUE(key_copy->ExportPublicKey(&pubkey_copy)); diff --git a/crypto/scoped_capi_types.h b/crypto/scoped_capi_types.h index ac92e39..74e5765 100644 --- a/crypto/scoped_capi_types.h +++ b/crypto/scoped_capi_types.h @@ -10,6 +10,7 @@ #include <algorithm> #include "base/logging.h" +#include "base/macros.h" #include "crypto/wincrypt_shim.h" namespace crypto { diff --git a/crypto/scoped_openssl_types.h b/crypto/scoped_openssl_types.h index bdae6aa..9bc5d74 100644 --- a/crypto/scoped_openssl_types.h +++ b/crypto/scoped_openssl_types.h @@ -13,6 +13,7 @@ #include <openssl/evp.h> #include <openssl/mem.h> #include <openssl/rsa.h> +#include <stdint.h> #include "base/memory/scoped_ptr.h" diff --git a/crypto/secure_hash.h b/crypto/secure_hash.h index 23349b0..491a299a3 100644 --- a/crypto/secure_hash.h +++ b/crypto/secure_hash.h @@ -5,7 +5,9 @@ #ifndef CRYPTO_SECURE_HASH_H_ #define CRYPTO_SECURE_HASH_H_ -#include "base/basictypes.h" +#include <stddef.h> + +#include "base/macros.h" #include "crypto/crypto_export.h" namespace base { diff --git a/crypto/secure_hash_default.cc b/crypto/secure_hash_default.cc index 739b402..cec6fb8 100644 --- a/crypto/secure_hash_default.cc +++ b/crypto/secure_hash_default.cc @@ -4,6 +4,8 @@ #include "crypto/secure_hash.h" +#include <stddef.h> + #include "base/logging.h" #include "base/pickle.h" #include "crypto/third_party/nss/chromium-blapi.h" diff --git a/crypto/secure_hash_openssl.cc b/crypto/secure_hash_openssl.cc index 1033b8e..ec859ff 100644 --- a/crypto/secure_hash_openssl.cc +++ b/crypto/secure_hash_openssl.cc @@ -6,8 +6,8 @@ #include <openssl/mem.h> #include <openssl/sha.h> +#include <stddef.h> -#include "base/basictypes.h" #include "base/logging.h" #include "base/pickle.h" #include "crypto/openssl_util.h" diff --git a/crypto/secure_hash_unittest.cc b/crypto/secure_hash_unittest.cc index facf476..df0afa6 100644 --- a/crypto/secure_hash_unittest.cc +++ b/crypto/secure_hash_unittest.cc @@ -4,9 +4,11 @@ #include "crypto/secure_hash.h" +#include <stddef.h> +#include <stdint.h> + #include <string> -#include "base/basictypes.h" #include "base/memory/scoped_ptr.h" #include "base/pickle.h" #include "crypto/sha2.h" @@ -24,7 +26,7 @@ TEST(SecureHashTest, TestUpdate) { 0x04, 0x6d, 0x39, 0xcc, 0xc7, 0x11, 0x2c, 0xd0 }; - uint8 output3[crypto::kSHA256Length]; + uint8_t output3[crypto::kSHA256Length]; scoped_ptr<crypto::SecureHash> ctx(crypto::SecureHash::Create( crypto::SecureHash::SHA256)); @@ -46,8 +48,8 @@ TEST(SecureHashTest, TestSerialization) { std::string input4(10001, 'd'); // 'd' repeated 10001 times std::string input5(10001, 'e'); // 'e' repeated 10001 times - uint8 output1[crypto::kSHA256Length]; - uint8 output2[crypto::kSHA256Length]; + uint8_t output1[crypto::kSHA256Length]; + uint8_t output2[crypto::kSHA256Length]; scoped_ptr<crypto::SecureHash> ctx1(crypto::SecureHash::Create( crypto::SecureHash::SHA256)); diff --git a/crypto/secure_util.cc b/crypto/secure_util.cc index 3fe8aa9..fe86d65 100644 --- a/crypto/secure_util.cc +++ b/crypto/secure_util.cc @@ -2,6 +2,8 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +#include <stddef.h> + #include "crypto/secure_util.h" namespace crypto { diff --git a/crypto/sha2.cc b/crypto/sha2.cc index 6f36237..2646d1b 100644 --- a/crypto/sha2.cc +++ b/crypto/sha2.cc @@ -4,6 +4,8 @@ #include "crypto/sha2.h" +#include <stddef.h> + #include "base/memory/scoped_ptr.h" #include "base/stl_util.h" #include "crypto/secure_hash.h" diff --git a/crypto/sha2.h b/crypto/sha2.h index 7e279d3..d575815 100644 --- a/crypto/sha2.h +++ b/crypto/sha2.h @@ -5,6 +5,8 @@ #ifndef CRYPTO_SHA2_H_ #define CRYPTO_SHA2_H_ +#include <stddef.h> + #include <string> #include "base/strings/string_piece.h" diff --git a/crypto/sha2_unittest.cc b/crypto/sha2_unittest.cc index 78da136..27d6d25 100644 --- a/crypto/sha2_unittest.cc +++ b/crypto/sha2_unittest.cc @@ -4,7 +4,9 @@ #include "crypto/sha2.h" -#include "base/basictypes.h" +#include <stddef.h> +#include <stdint.h> + #include "testing/gtest/include/gtest/gtest.h" TEST(Sha256Test, Test1) { @@ -19,12 +21,12 @@ TEST(Sha256Test, Test1) { 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad }; - uint8 output1[crypto::kSHA256Length]; + uint8_t output1[crypto::kSHA256Length]; crypto::SHA256HashString(input1, output1, sizeof(output1)); for (size_t i = 0; i < crypto::kSHA256Length; i++) EXPECT_EQ(expected1[i], static_cast<int>(output1[i])); - uint8 output_truncated1[4]; // 4 bytes == 32 bits + uint8_t output_truncated1[4]; // 4 bytes == 32 bits crypto::SHA256HashString(input1, output_truncated1, sizeof(output_truncated1)); for (size_t i = 0; i < sizeof(output_truncated1); i++) @@ -47,7 +49,7 @@ TEST(Sha256Test, Test1_String) { std::string output1 = crypto::SHA256HashString(input1); ASSERT_EQ(crypto::kSHA256Length, output1.size()); for (size_t i = 0; i < crypto::kSHA256Length; i++) - EXPECT_EQ(expected1[i], static_cast<uint8>(output1[i])); + EXPECT_EQ(expected1[i], static_cast<uint8_t>(output1[i])); } TEST(Sha256Test, Test2) { @@ -63,12 +65,12 @@ TEST(Sha256Test, Test2) { 0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1 }; - uint8 output2[crypto::kSHA256Length]; + uint8_t output2[crypto::kSHA256Length]; crypto::SHA256HashString(input2, output2, sizeof(output2)); for (size_t i = 0; i < crypto::kSHA256Length; i++) EXPECT_EQ(expected2[i], static_cast<int>(output2[i])); - uint8 output_truncated2[6]; + uint8_t output_truncated2[6]; crypto::SHA256HashString(input2, output_truncated2, sizeof(output_truncated2)); for (size_t i = 0; i < sizeof(output_truncated2); i++) @@ -87,12 +89,12 @@ TEST(Sha256Test, Test3) { 0x04, 0x6d, 0x39, 0xcc, 0xc7, 0x11, 0x2c, 0xd0 }; - uint8 output3[crypto::kSHA256Length]; + uint8_t output3[crypto::kSHA256Length]; crypto::SHA256HashString(input3, output3, sizeof(output3)); for (size_t i = 0; i < crypto::kSHA256Length; i++) EXPECT_EQ(expected3[i], static_cast<int>(output3[i])); - uint8 output_truncated3[12]; + uint8_t output_truncated3[12]; crypto::SHA256HashString(input3, output_truncated3, sizeof(output_truncated3)); for (size_t i = 0; i < sizeof(output_truncated3); i++) diff --git a/crypto/signature_creator.h b/crypto/signature_creator.h index ab9d2c1..abd1546 100644 --- a/crypto/signature_creator.h +++ b/crypto/signature_creator.h @@ -5,10 +5,12 @@ #ifndef CRYPTO_SIGNATURE_CREATOR_H_ #define CRYPTO_SIGNATURE_CREATOR_H_ +#include <stdint.h> + #include <vector> +#include "base/macros.h" #include "build/build_config.h" -#include "base/basictypes.h" #include "crypto/crypto_export.h" #if defined(USE_OPENSSL) @@ -45,15 +47,15 @@ class CRYPTO_EXPORT SignatureCreator { // specified in PKCS #1 v1.5. static bool Sign(RSAPrivateKey* key, HashAlgorithm hash_alg, - const uint8* data, + const uint8_t* data, int data_len, - std::vector<uint8>* signature); + std::vector<uint8_t>* signature); // Update the signature with more data. - bool Update(const uint8* data_part, int data_part_len); + bool Update(const uint8_t* data_part, int data_part_len); // Finalize the signature. - bool Final(std::vector<uint8>* signature); + bool Final(std::vector<uint8_t>* signature); private: // Private constructor. Use the Create() method instead. diff --git a/crypto/signature_creator_nss.cc b/crypto/signature_creator_nss.cc index da03312..bf20413 100644 --- a/crypto/signature_creator_nss.cc +++ b/crypto/signature_creator_nss.cc @@ -6,6 +6,7 @@ #include <cryptohi.h> #include <keyhi.h> +#include <stdint.h> #include <stdlib.h> #include "base/logging.h" @@ -68,9 +69,9 @@ SignatureCreator* SignatureCreator::Create(RSAPrivateKey* key, // static bool SignatureCreator::Sign(RSAPrivateKey* key, HashAlgorithm hash_alg, - const uint8* data, + const uint8_t* data, int data_len, - std::vector<uint8>* signature) { + std::vector<uint8_t>* signature) { SECItem data_item; data_item.type = siBuffer; data_item.data = const_cast<unsigned char*>(data); @@ -89,7 +90,7 @@ bool SignatureCreator::Sign(RSAPrivateKey* key, return true; } -bool SignatureCreator::Update(const uint8* data_part, int data_part_len) { +bool SignatureCreator::Update(const uint8_t* data_part, int data_part_len) { SECStatus rv = SGN_Update(sign_context_, data_part, data_part_len); if (rv != SECSuccess) { NOTREACHED(); @@ -99,7 +100,7 @@ bool SignatureCreator::Update(const uint8* data_part, int data_part_len) { return true; } -bool SignatureCreator::Final(std::vector<uint8>* signature) { +bool SignatureCreator::Final(std::vector<uint8_t>* signature) { SECItem signature_item; SECStatus rv = SGN_End(sign_context_, &signature_item); if (rv != SECSuccess) { diff --git a/crypto/signature_creator_openssl.cc b/crypto/signature_creator_openssl.cc index 3dc64cd..d5fc4d4 100644 --- a/crypto/signature_creator_openssl.cc +++ b/crypto/signature_creator_openssl.cc @@ -6,6 +6,8 @@ #include <openssl/evp.h> #include <openssl/rsa.h> +#include <stddef.h> +#include <stdint.h> #include "base/logging.h" #include "base/memory/scoped_ptr.h" @@ -59,9 +61,9 @@ SignatureCreator* SignatureCreator::Create(RSAPrivateKey* key, // static bool SignatureCreator::Sign(RSAPrivateKey* key, HashAlgorithm hash_alg, - const uint8* data, + const uint8_t* data, int data_len, - std::vector<uint8>* signature) { + std::vector<uint8_t>* signature) { ScopedRSA rsa_key(EVP_PKEY_get1_RSA(key->key())); if (!rsa_key) return false; @@ -85,12 +87,12 @@ SignatureCreator::~SignatureCreator() { EVP_MD_CTX_destroy(sign_context_); } -bool SignatureCreator::Update(const uint8* data_part, int data_part_len) { +bool SignatureCreator::Update(const uint8_t* data_part, int data_part_len) { OpenSSLErrStackTracer err_tracer(FROM_HERE); return !!EVP_DigestSignUpdate(sign_context_, data_part, data_part_len); } -bool SignatureCreator::Final(std::vector<uint8>* signature) { +bool SignatureCreator::Final(std::vector<uint8_t>* signature) { OpenSSLErrStackTracer err_tracer(FROM_HERE); // Determine the maximum length of the signature. diff --git a/crypto/signature_creator_unittest.cc b/crypto/signature_creator_unittest.cc index 694becd..af1a042 100644 --- a/crypto/signature_creator_unittest.cc +++ b/crypto/signature_creator_unittest.cc @@ -2,6 +2,8 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +#include <stdint.h> + #include <vector> #include "base/memory/scoped_ptr.h" @@ -15,17 +17,14 @@ namespace { // This is the algorithm ID for SHA-1 with RSA encryption. -const uint8 kSHA1WithRSAAlgorithmID[] = { - 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, - 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, 0x00 -}; +const uint8_t kSHA1WithRSAAlgorithmID[] = {0x30, 0x0d, 0x06, 0x09, 0x2a, + 0x86, 0x48, 0x86, 0xf7, 0x0d, + 0x01, 0x01, 0x05, 0x05, 0x00}; // This is the algorithm ID for SHA-1 with RSA encryption. -const uint8 kSHA256WithRSAAlgorithmID[] = { - 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, - 0xf7, 0x0d, 0x01, 0x01, 0x0B, 0x05, 0x00 -}; - +const uint8_t kSHA256WithRSAAlgorithmID[] = {0x30, 0x0d, 0x06, 0x09, 0x2a, + 0x86, 0x48, 0x86, 0xf7, 0x0d, + 0x01, 0x01, 0x0B, 0x05, 0x00}; } TEST(SignatureCreatorTest, BasicTest) { @@ -34,7 +33,7 @@ TEST(SignatureCreatorTest, BasicTest) { crypto::RSAPrivateKey::Create(1024)); ASSERT_TRUE(key_original.get()); - std::vector<uint8> key_info; + std::vector<uint8_t> key_info; key_original->ExportPrivateKey(&key_info); scoped_ptr<crypto::RSAPrivateKey> key( crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_info)); @@ -46,13 +45,13 @@ TEST(SignatureCreatorTest, BasicTest) { ASSERT_TRUE(signer.get()); std::string data("Hello, World!"); - ASSERT_TRUE(signer->Update(reinterpret_cast<const uint8*>(data.c_str()), + ASSERT_TRUE(signer->Update(reinterpret_cast<const uint8_t*>(data.c_str()), data.size())); - std::vector<uint8> signature; + std::vector<uint8_t> signature; ASSERT_TRUE(signer->Final(&signature)); - std::vector<uint8> public_key_info; + std::vector<uint8_t> public_key_info; ASSERT_TRUE(key_original->ExportPublicKey(&public_key_info)); crypto::SignatureVerifier verifier; @@ -61,7 +60,7 @@ TEST(SignatureCreatorTest, BasicTest) { &signature.front(), signature.size(), &public_key_info.front(), public_key_info.size())); - verifier.VerifyUpdate(reinterpret_cast<const uint8*>(data.c_str()), + verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(data.c_str()), data.size()); ASSERT_TRUE(verifier.VerifyFinal()); } @@ -72,7 +71,7 @@ TEST(SignatureCreatorTest, SignDigestTest) { crypto::RSAPrivateKey::Create(1024)); ASSERT_TRUE(key_original.get()); - std::vector<uint8> key_info; + std::vector<uint8_t> key_info; key_original->ExportPrivateKey(&key_info); scoped_ptr<crypto::RSAPrivateKey> key( crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_info)); @@ -81,15 +80,12 @@ TEST(SignatureCreatorTest, SignDigestTest) { std::string data("Hello, World!"); std::string sha1 = base::SHA1HashString(data); // Sign sha1 of the input data. - std::vector<uint8> signature; + std::vector<uint8_t> signature; ASSERT_TRUE(crypto::SignatureCreator::Sign( - key.get(), - crypto::SignatureCreator::SHA1, - reinterpret_cast<const uint8*>(sha1.c_str()), - sha1.size(), - &signature)); + key.get(), crypto::SignatureCreator::SHA1, + reinterpret_cast<const uint8_t*>(sha1.c_str()), sha1.size(), &signature)); - std::vector<uint8> public_key_info; + std::vector<uint8_t> public_key_info; ASSERT_TRUE(key_original->ExportPublicKey(&public_key_info)); // Verify the input data. @@ -99,7 +95,7 @@ TEST(SignatureCreatorTest, SignDigestTest) { &signature.front(), signature.size(), &public_key_info.front(), public_key_info.size())); - verifier.VerifyUpdate(reinterpret_cast<const uint8*>(data.c_str()), + verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(data.c_str()), data.size()); ASSERT_TRUE(verifier.VerifyFinal()); } @@ -110,7 +106,7 @@ TEST(SignatureCreatorTest, SignSHA256DigestTest) { crypto::RSAPrivateKey::Create(1024)); ASSERT_TRUE(key_original.get()); - std::vector<uint8> key_info; + std::vector<uint8_t> key_info; key_original->ExportPrivateKey(&key_info); scoped_ptr<crypto::RSAPrivateKey> key( crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_info)); @@ -119,15 +115,13 @@ TEST(SignatureCreatorTest, SignSHA256DigestTest) { std::string data("Hello, World!"); std::string sha256 = crypto::SHA256HashString(data); // Sign sha256 of the input data. - std::vector<uint8> signature; + std::vector<uint8_t> signature; ASSERT_TRUE(crypto::SignatureCreator::Sign( - key.get(), - crypto::SignatureCreator::HashAlgorithm::SHA256, - reinterpret_cast<const uint8*>(sha256.c_str()), - sha256.size(), + key.get(), crypto::SignatureCreator::HashAlgorithm::SHA256, + reinterpret_cast<const uint8_t*>(sha256.c_str()), sha256.size(), &signature)); - std::vector<uint8> public_key_info; + std::vector<uint8_t> public_key_info; ASSERT_TRUE(key_original->ExportPublicKey(&public_key_info)); // Verify the input data. @@ -137,7 +131,7 @@ TEST(SignatureCreatorTest, SignSHA256DigestTest) { &signature.front(), signature.size(), &public_key_info.front(), public_key_info.size())); - verifier.VerifyUpdate(reinterpret_cast<const uint8*>(data.c_str()), + verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(data.c_str()), data.size()); ASSERT_TRUE(verifier.VerifyFinal()); } diff --git a/crypto/signature_verifier.h b/crypto/signature_verifier.h index fbf87d4..b26a0df 100644 --- a/crypto/signature_verifier.h +++ b/crypto/signature_verifier.h @@ -5,10 +5,11 @@ #ifndef CRYPTO_SIGNATURE_VERIFIER_H_ #define CRYPTO_SIGNATURE_VERIFIER_H_ +#include <stdint.h> + #include <vector> #include "build/build_config.h" -#include "base/basictypes.h" #include "crypto/crypto_export.h" #if defined(USE_OPENSSL) @@ -58,11 +59,11 @@ class CRYPTO_EXPORT SignatureVerifier { // SubjectPublicKeyInfo ::= SEQUENCE { // algorithm AlgorithmIdentifier, // subjectPublicKey BIT STRING } - bool VerifyInit(const uint8* signature_algorithm, + bool VerifyInit(const uint8_t* signature_algorithm, int signature_algorithm_len, - const uint8* signature, + const uint8_t* signature, int signature_len, - const uint8* public_key_info, + const uint8_t* public_key_info, int public_key_info_len); // Initiates a RSA-PSS signature verification operation. This should be @@ -84,13 +85,13 @@ class CRYPTO_EXPORT SignatureVerifier { bool VerifyInitRSAPSS(HashAlgorithm hash_alg, HashAlgorithm mask_hash_alg, int salt_len, - const uint8* signature, + const uint8_t* signature, int signature_len, - const uint8* public_key_info, + const uint8_t* public_key_info, int public_key_info_len); // Feeds a piece of the data to the signature verifier. - void VerifyUpdate(const uint8* data_part, int data_part_len); + void VerifyUpdate(const uint8_t* data_part, int data_part_len); // Concludes a signature verification operation. Returns true if the // signature is valid. Returns false if the signature is invalid or an @@ -98,31 +99,31 @@ class CRYPTO_EXPORT SignatureVerifier { bool VerifyFinal(); // Note: we can provide a one-shot interface if there is interest: - // bool Verify(const uint8* data, + // bool Verify(const uint8_t* data, // int data_len, - // const uint8* signature_algorithm, + // const uint8_t* signature_algorithm, // int signature_algorithm_len, - // const uint8* signature, + // const uint8_t* signature, // int signature_len, - // const uint8* public_key_info, + // const uint8_t* public_key_info, // int public_key_info_len); private: #if defined(USE_OPENSSL) bool CommonInit(const EVP_MD* digest, - const uint8* signature, + const uint8_t* signature, int signature_len, - const uint8* public_key_info, + const uint8_t* public_key_info, int public_key_info_len, EVP_PKEY_CTX** pkey_ctx); #else - static SECKEYPublicKey* DecodePublicKeyInfo(const uint8* public_key_info, + static SECKEYPublicKey* DecodePublicKeyInfo(const uint8_t* public_key_info, int public_key_info_len); #endif void Reset(); - std::vector<uint8> signature_; + std::vector<uint8_t> signature_; #if defined(USE_OPENSSL) struct VerifyContext; diff --git a/crypto/signature_verifier_nss.cc b/crypto/signature_verifier_nss.cc index 5be620d..e6cd3e0 100644 --- a/crypto/signature_verifier_nss.cc +++ b/crypto/signature_verifier_nss.cc @@ -9,6 +9,7 @@ #include <pk11pub.h> #include <secerr.h> #include <sechash.h> +#include <stdint.h> #include <stdlib.h> #include "base/logging.h" @@ -73,11 +74,11 @@ SignatureVerifier::~SignatureVerifier() { Reset(); } -bool SignatureVerifier::VerifyInit(const uint8* signature_algorithm, +bool SignatureVerifier::VerifyInit(const uint8_t* signature_algorithm, int signature_algorithm_len, - const uint8* signature, + const uint8_t* signature, int signature_len, - const uint8* public_key_info, + const uint8_t* public_key_info, int public_key_info_len) { if (vfy_context_ || hash_context_) return false; @@ -97,7 +98,7 @@ bool SignatureVerifier::VerifyInit(const uint8* signature_algorithm, SECItem sig_alg_der; sig_alg_der.type = siBuffer; - sig_alg_der.data = const_cast<uint8*>(signature_algorithm); + sig_alg_der.data = const_cast<uint8_t*>(signature_algorithm); sig_alg_der.len = signature_algorithm_len; SECAlgorithmID sig_alg_id; SECStatus rv; @@ -112,7 +113,7 @@ bool SignatureVerifier::VerifyInit(const uint8* signature_algorithm, SECItem sig; sig.type = siBuffer; - sig.data = const_cast<uint8*>(signature); + sig.data = const_cast<uint8_t*>(signature); sig.len = signature_len; SECOidTag hash_alg_tag; vfy_context_ = VFY_CreateContextWithAlgorithmID(public_key, &sig, @@ -138,9 +139,9 @@ bool SignatureVerifier::VerifyInit(const uint8* signature_algorithm, bool SignatureVerifier::VerifyInitRSAPSS(HashAlgorithm hash_alg, HashAlgorithm mask_hash_alg, int salt_len, - const uint8* signature, + const uint8_t* signature, int signature_len, - const uint8* public_key_info, + const uint8_t* public_key_info, int public_key_info_len) { if (vfy_context_ || hash_context_) return false; @@ -163,7 +164,7 @@ bool SignatureVerifier::VerifyInitRSAPSS(HashAlgorithm hash_alg, return true; } -void SignatureVerifier::VerifyUpdate(const uint8* data_part, +void SignatureVerifier::VerifyUpdate(const uint8_t* data_part, int data_part_len) { if (vfy_context_) { SECStatus rv = VFY_Update(vfy_context_, data_part, data_part_len); @@ -192,12 +193,12 @@ bool SignatureVerifier::VerifyFinal() { // static SECKEYPublicKey* SignatureVerifier::DecodePublicKeyInfo( - const uint8* public_key_info, + const uint8_t* public_key_info, int public_key_info_len) { CERTSubjectPublicKeyInfo* spki = NULL; SECItem spki_der; spki_der.type = siBuffer; - spki_der.data = const_cast<uint8*>(public_key_info); + spki_der.data = const_cast<uint8_t*>(public_key_info); spki_der.len = public_key_info_len; spki = SECKEY_DecodeDERSubjectPublicKeyInfo(&spki_der); if (!spki) diff --git a/crypto/signature_verifier_openssl.cc b/crypto/signature_verifier_openssl.cc index 309cb4c..a756149 100644 --- a/crypto/signature_verifier_openssl.cc +++ b/crypto/signature_verifier_openssl.cc @@ -6,6 +6,7 @@ #include <openssl/evp.h> #include <openssl/x509.h> +#include <stdint.h> #include <vector> @@ -42,11 +43,11 @@ SignatureVerifier::~SignatureVerifier() { Reset(); } -bool SignatureVerifier::VerifyInit(const uint8* signature_algorithm, +bool SignatureVerifier::VerifyInit(const uint8_t* signature_algorithm, int signature_algorithm_len, - const uint8* signature, + const uint8_t* signature, int signature_len, - const uint8* public_key_info, + const uint8_t* public_key_info, int public_key_info_len) { OpenSSLErrStackTracer err_tracer(FROM_HERE); ScopedOpenSSL<X509_ALGOR, X509_ALGOR_free> algorithm( @@ -74,9 +75,9 @@ bool SignatureVerifier::VerifyInit(const uint8* signature_algorithm, bool SignatureVerifier::VerifyInitRSAPSS(HashAlgorithm hash_alg, HashAlgorithm mask_hash_alg, int salt_len, - const uint8* signature, + const uint8_t* signature, int signature_len, - const uint8* public_key_info, + const uint8_t* public_key_info, int public_key_info_len) { OpenSSLErrStackTracer err_tracer(FROM_HERE); const EVP_MD* const digest = ToOpenSSLDigest(hash_alg); @@ -106,7 +107,7 @@ bool SignatureVerifier::VerifyInitRSAPSS(HashAlgorithm hash_alg, return rv == 1; } -void SignatureVerifier::VerifyUpdate(const uint8* data_part, +void SignatureVerifier::VerifyUpdate(const uint8_t* data_part, int data_part_len) { DCHECK(verify_context_); OpenSSLErrStackTracer err_tracer(FROM_HERE); @@ -126,9 +127,9 @@ bool SignatureVerifier::VerifyFinal() { } bool SignatureVerifier::CommonInit(const EVP_MD* digest, - const uint8* signature, + const uint8_t* signature, int signature_len, - const uint8* public_key_info, + const uint8_t* public_key_info, int public_key_info_len, EVP_PKEY_CTX** pkey_ctx) { if (verify_context_) diff --git a/crypto/signature_verifier_unittest.cc b/crypto/signature_verifier_unittest.cc index a661ff7..adcc885 100644 --- a/crypto/signature_verifier_unittest.cc +++ b/crypto/signature_verifier_unittest.cc @@ -4,6 +4,10 @@ #include "crypto/signature_verifier.h" +#include <stddef.h> +#include <stdint.h> + +#include "base/macros.h" #include "base/numerics/safe_conversions.h" #include "testing/gtest/include/gtest/gtest.h" @@ -24,181 +28,174 @@ TEST(SignatureVerifierTest, BasicTest) { // TBSCertificate ::= SEQUENCE { // ... -- omitted, not important // } - const uint8 tbs_certificate[1017] = { - 0x30, 0x82, 0x03, 0xf5, // a SEQUENCE of length 1013 (0x3f5) - 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x03, 0x43, 0xdd, 0x63, 0x30, 0x0d, - 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, - 0x00, 0x30, 0x81, 0xca, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, - 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x10, 0x30, 0x0e, 0x06, 0x03, 0x55, - 0x04, 0x08, 0x13, 0x07, 0x41, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x61, 0x31, - 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x0a, 0x53, 0x63, - 0x6f, 0x74, 0x74, 0x73, 0x64, 0x61, 0x6c, 0x65, 0x31, 0x1a, 0x30, 0x18, - 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x11, 0x47, 0x6f, 0x44, 0x61, 0x64, - 0x64, 0x79, 0x2e, 0x63, 0x6f, 0x6d, 0x2c, 0x20, 0x49, 0x6e, 0x63, 0x2e, - 0x31, 0x33, 0x30, 0x31, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x13, 0x2a, 0x68, - 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, - 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x2e, 0x67, 0x6f, 0x64, 0x61, 0x64, - 0x64, 0x79, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, - 0x69, 0x74, 0x6f, 0x72, 0x79, 0x31, 0x30, 0x30, 0x2e, 0x06, 0x03, 0x55, - 0x04, 0x03, 0x13, 0x27, 0x47, 0x6f, 0x20, 0x44, 0x61, 0x64, 0x64, 0x79, - 0x20, 0x53, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x43, 0x65, 0x72, 0x74, - 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x75, - 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x31, 0x11, 0x30, 0x0f, 0x06, - 0x03, 0x55, 0x04, 0x05, 0x13, 0x08, 0x30, 0x37, 0x39, 0x36, 0x39, 0x32, - 0x38, 0x37, 0x30, 0x1e, 0x17, 0x0d, 0x30, 0x38, 0x30, 0x33, 0x31, 0x38, - 0x32, 0x33, 0x33, 0x35, 0x31, 0x39, 0x5a, 0x17, 0x0d, 0x31, 0x31, 0x30, - 0x33, 0x31, 0x38, 0x32, 0x33, 0x33, 0x35, 0x31, 0x39, 0x5a, 0x30, 0x79, - 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, - 0x53, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0a, - 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x31, 0x12, - 0x30, 0x10, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x09, 0x43, 0x75, 0x70, - 0x65, 0x72, 0x74, 0x69, 0x6e, 0x6f, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, - 0x55, 0x04, 0x0a, 0x13, 0x0a, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x49, - 0x6e, 0x63, 0x2e, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x0b, - 0x13, 0x0c, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x46, 0x6f, 0x72, - 0x67, 0x65, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, - 0x0c, 0x2a, 0x2e, 0x77, 0x65, 0x62, 0x6b, 0x69, 0x74, 0x2e, 0x6f, 0x72, - 0x67, 0x30, 0x81, 0x9f, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, - 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x81, 0x8d, 0x00, 0x30, - 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0xa7, 0x62, 0x79, 0x41, 0xda, 0x28, - 0xf2, 0xc0, 0x4f, 0xe0, 0x25, 0xaa, 0xa1, 0x2e, 0x3b, 0x30, 0x94, 0xb5, - 0xc9, 0x26, 0x3a, 0x1b, 0xe2, 0xd0, 0xcc, 0xa2, 0x95, 0xe2, 0x91, 0xc0, - 0xf0, 0x40, 0x9e, 0x27, 0x6e, 0xbd, 0x6e, 0xde, 0x7c, 0xb6, 0x30, 0x5c, - 0xb8, 0x9b, 0x01, 0x2f, 0x92, 0x04, 0xa1, 0xef, 0x4a, 0xb1, 0x6c, 0xb1, - 0x7e, 0x8e, 0xcd, 0xa6, 0xf4, 0x40, 0x73, 0x1f, 0x2c, 0x96, 0xad, 0xff, - 0x2a, 0x6d, 0x0e, 0xba, 0x52, 0x84, 0x83, 0xb0, 0x39, 0xee, 0xc9, 0x39, - 0xdc, 0x1e, 0x34, 0xd0, 0xd8, 0x5d, 0x7a, 0x09, 0xac, 0xa9, 0xee, 0xca, - 0x65, 0xf6, 0x85, 0x3a, 0x6b, 0xee, 0xe4, 0x5c, 0x5e, 0xf8, 0xda, 0xd1, - 0xce, 0x88, 0x47, 0xcd, 0x06, 0x21, 0xe0, 0xb9, 0x4b, 0xe4, 0x07, 0xcb, - 0x57, 0xdc, 0xca, 0x99, 0x54, 0xf7, 0x0e, 0xd5, 0x17, 0x95, 0x05, 0x2e, - 0xe9, 0xb1, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x82, 0x01, 0xce, 0x30, - 0x82, 0x01, 0xca, 0x30, 0x09, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x04, 0x02, - 0x30, 0x00, 0x30, 0x0b, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x04, 0x04, 0x03, - 0x02, 0x05, 0xa0, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x04, 0x16, - 0x30, 0x14, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01, - 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x02, 0x30, 0x57, - 0x06, 0x03, 0x55, 0x1d, 0x1f, 0x04, 0x50, 0x30, 0x4e, 0x30, 0x4c, 0xa0, - 0x4a, 0xa0, 0x48, 0x86, 0x46, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, - 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, - 0x2e, 0x67, 0x6f, 0x64, 0x61, 0x64, 0x64, 0x79, 0x2e, 0x63, 0x6f, 0x6d, - 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, - 0x67, 0x6f, 0x64, 0x61, 0x64, 0x64, 0x79, 0x65, 0x78, 0x74, 0x65, 0x6e, - 0x64, 0x65, 0x64, 0x69, 0x73, 0x73, 0x75, 0x69, 0x6e, 0x67, 0x33, 0x2e, - 0x63, 0x72, 0x6c, 0x30, 0x52, 0x06, 0x03, 0x55, 0x1d, 0x20, 0x04, 0x4b, - 0x30, 0x49, 0x30, 0x47, 0x06, 0x0b, 0x60, 0x86, 0x48, 0x01, 0x86, 0xfd, - 0x6d, 0x01, 0x07, 0x17, 0x02, 0x30, 0x38, 0x30, 0x36, 0x06, 0x08, 0x2b, - 0x06, 0x01, 0x05, 0x05, 0x07, 0x02, 0x01, 0x16, 0x2a, 0x68, 0x74, 0x74, - 0x70, 0x3a, 0x2f, 0x2f, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, - 0x61, 0x74, 0x65, 0x73, 0x2e, 0x67, 0x6f, 0x64, 0x61, 0x64, 0x64, 0x79, - 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x6f, 0x72, 0x79, 0x30, 0x7f, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, - 0x07, 0x01, 0x01, 0x04, 0x73, 0x30, 0x71, 0x30, 0x23, 0x06, 0x08, 0x2b, - 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x01, 0x86, 0x17, 0x68, 0x74, 0x74, - 0x70, 0x3a, 0x2f, 0x2f, 0x6f, 0x63, 0x73, 0x70, 0x2e, 0x67, 0x6f, 0x64, - 0x61, 0x64, 0x64, 0x79, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x4a, 0x06, 0x08, - 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x02, 0x86, 0x3e, 0x68, 0x74, - 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, - 0x63, 0x61, 0x74, 0x65, 0x73, 0x2e, 0x67, 0x6f, 0x64, 0x61, 0x64, 0x64, - 0x79, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x67, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x65, - 0x72, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x2e, 0x63, 0x72, 0x74, - 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x48, - 0xdf, 0x60, 0x32, 0xcc, 0x89, 0x01, 0xb6, 0xdc, 0x2f, 0xe3, 0x73, 0xb5, - 0x9c, 0x16, 0x58, 0x32, 0x68, 0xa9, 0xc3, 0x30, 0x1f, 0x06, 0x03, 0x55, - 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xfd, 0xac, 0x61, 0x32, - 0x93, 0x6c, 0x45, 0xd6, 0xe2, 0xee, 0x85, 0x5f, 0x9a, 0xba, 0xe7, 0x76, - 0x99, 0x68, 0xcc, 0xe7, 0x30, 0x23, 0x06, 0x03, 0x55, 0x1d, 0x11, 0x04, - 0x1c, 0x30, 0x1a, 0x82, 0x0c, 0x2a, 0x2e, 0x77, 0x65, 0x62, 0x6b, 0x69, - 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x82, 0x0a, 0x77, 0x65, 0x62, 0x6b, 0x69, - 0x74, 0x2e, 0x6f, 0x72, 0x67 - }; + const uint8_t tbs_certificate[1017] = { + 0x30, 0x82, 0x03, 0xf5, // a SEQUENCE of length 1013 (0x3f5) + 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x03, 0x43, 0xdd, 0x63, 0x30, 0x0d, + 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, + 0x00, 0x30, 0x81, 0xca, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, + 0x06, 0x13, 0x02, 0x55, 0x53, 0x31, 0x10, 0x30, 0x0e, 0x06, 0x03, 0x55, + 0x04, 0x08, 0x13, 0x07, 0x41, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x61, 0x31, + 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x0a, 0x53, 0x63, + 0x6f, 0x74, 0x74, 0x73, 0x64, 0x61, 0x6c, 0x65, 0x31, 0x1a, 0x30, 0x18, + 0x06, 0x03, 0x55, 0x04, 0x0a, 0x13, 0x11, 0x47, 0x6f, 0x44, 0x61, 0x64, + 0x64, 0x79, 0x2e, 0x63, 0x6f, 0x6d, 0x2c, 0x20, 0x49, 0x6e, 0x63, 0x2e, + 0x31, 0x33, 0x30, 0x31, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x13, 0x2a, 0x68, + 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x2e, 0x67, 0x6f, 0x64, 0x61, 0x64, + 0x64, 0x79, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x6f, 0x72, 0x79, 0x31, 0x30, 0x30, 0x2e, 0x06, 0x03, 0x55, + 0x04, 0x03, 0x13, 0x27, 0x47, 0x6f, 0x20, 0x44, 0x61, 0x64, 0x64, 0x79, + 0x20, 0x53, 0x65, 0x63, 0x75, 0x72, 0x65, 0x20, 0x43, 0x65, 0x72, 0x74, + 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x41, 0x75, + 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x31, 0x11, 0x30, 0x0f, 0x06, + 0x03, 0x55, 0x04, 0x05, 0x13, 0x08, 0x30, 0x37, 0x39, 0x36, 0x39, 0x32, + 0x38, 0x37, 0x30, 0x1e, 0x17, 0x0d, 0x30, 0x38, 0x30, 0x33, 0x31, 0x38, + 0x32, 0x33, 0x33, 0x35, 0x31, 0x39, 0x5a, 0x17, 0x0d, 0x31, 0x31, 0x30, + 0x33, 0x31, 0x38, 0x32, 0x33, 0x33, 0x35, 0x31, 0x39, 0x5a, 0x30, 0x79, + 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x55, + 0x53, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x13, 0x0a, + 0x43, 0x61, 0x6c, 0x69, 0x66, 0x6f, 0x72, 0x6e, 0x69, 0x61, 0x31, 0x12, + 0x30, 0x10, 0x06, 0x03, 0x55, 0x04, 0x07, 0x13, 0x09, 0x43, 0x75, 0x70, + 0x65, 0x72, 0x74, 0x69, 0x6e, 0x6f, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, + 0x55, 0x04, 0x0a, 0x13, 0x0a, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x49, + 0x6e, 0x63, 0x2e, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x0b, + 0x13, 0x0c, 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x46, 0x6f, 0x72, + 0x67, 0x65, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, + 0x0c, 0x2a, 0x2e, 0x77, 0x65, 0x62, 0x6b, 0x69, 0x74, 0x2e, 0x6f, 0x72, + 0x67, 0x30, 0x81, 0x9f, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, + 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x81, 0x8d, 0x00, 0x30, + 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0xa7, 0x62, 0x79, 0x41, 0xda, 0x28, + 0xf2, 0xc0, 0x4f, 0xe0, 0x25, 0xaa, 0xa1, 0x2e, 0x3b, 0x30, 0x94, 0xb5, + 0xc9, 0x26, 0x3a, 0x1b, 0xe2, 0xd0, 0xcc, 0xa2, 0x95, 0xe2, 0x91, 0xc0, + 0xf0, 0x40, 0x9e, 0x27, 0x6e, 0xbd, 0x6e, 0xde, 0x7c, 0xb6, 0x30, 0x5c, + 0xb8, 0x9b, 0x01, 0x2f, 0x92, 0x04, 0xa1, 0xef, 0x4a, 0xb1, 0x6c, 0xb1, + 0x7e, 0x8e, 0xcd, 0xa6, 0xf4, 0x40, 0x73, 0x1f, 0x2c, 0x96, 0xad, 0xff, + 0x2a, 0x6d, 0x0e, 0xba, 0x52, 0x84, 0x83, 0xb0, 0x39, 0xee, 0xc9, 0x39, + 0xdc, 0x1e, 0x34, 0xd0, 0xd8, 0x5d, 0x7a, 0x09, 0xac, 0xa9, 0xee, 0xca, + 0x65, 0xf6, 0x85, 0x3a, 0x6b, 0xee, 0xe4, 0x5c, 0x5e, 0xf8, 0xda, 0xd1, + 0xce, 0x88, 0x47, 0xcd, 0x06, 0x21, 0xe0, 0xb9, 0x4b, 0xe4, 0x07, 0xcb, + 0x57, 0xdc, 0xca, 0x99, 0x54, 0xf7, 0x0e, 0xd5, 0x17, 0x95, 0x05, 0x2e, + 0xe9, 0xb1, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x82, 0x01, 0xce, 0x30, + 0x82, 0x01, 0xca, 0x30, 0x09, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x04, 0x02, + 0x30, 0x00, 0x30, 0x0b, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x04, 0x04, 0x03, + 0x02, 0x05, 0xa0, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x04, 0x16, + 0x30, 0x14, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01, + 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x02, 0x30, 0x57, + 0x06, 0x03, 0x55, 0x1d, 0x1f, 0x04, 0x50, 0x30, 0x4e, 0x30, 0x4c, 0xa0, + 0x4a, 0xa0, 0x48, 0x86, 0x46, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, + 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, + 0x2e, 0x67, 0x6f, 0x64, 0x61, 0x64, 0x64, 0x79, 0x2e, 0x63, 0x6f, 0x6d, + 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, + 0x67, 0x6f, 0x64, 0x61, 0x64, 0x64, 0x79, 0x65, 0x78, 0x74, 0x65, 0x6e, + 0x64, 0x65, 0x64, 0x69, 0x73, 0x73, 0x75, 0x69, 0x6e, 0x67, 0x33, 0x2e, + 0x63, 0x72, 0x6c, 0x30, 0x52, 0x06, 0x03, 0x55, 0x1d, 0x20, 0x04, 0x4b, + 0x30, 0x49, 0x30, 0x47, 0x06, 0x0b, 0x60, 0x86, 0x48, 0x01, 0x86, 0xfd, + 0x6d, 0x01, 0x07, 0x17, 0x02, 0x30, 0x38, 0x30, 0x36, 0x06, 0x08, 0x2b, + 0x06, 0x01, 0x05, 0x05, 0x07, 0x02, 0x01, 0x16, 0x2a, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, + 0x61, 0x74, 0x65, 0x73, 0x2e, 0x67, 0x6f, 0x64, 0x61, 0x64, 0x64, 0x79, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x6f, 0x72, 0x79, 0x30, 0x7f, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05, + 0x07, 0x01, 0x01, 0x04, 0x73, 0x30, 0x71, 0x30, 0x23, 0x06, 0x08, 0x2b, + 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x01, 0x86, 0x17, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x6f, 0x63, 0x73, 0x70, 0x2e, 0x67, 0x6f, 0x64, + 0x61, 0x64, 0x64, 0x79, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x4a, 0x06, 0x08, + 0x2b, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x02, 0x86, 0x3e, 0x68, 0x74, + 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, + 0x63, 0x61, 0x74, 0x65, 0x73, 0x2e, 0x67, 0x6f, 0x64, 0x61, 0x64, 0x64, + 0x79, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, + 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x67, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x74, 0x65, 0x2e, 0x63, 0x72, 0x74, + 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x48, + 0xdf, 0x60, 0x32, 0xcc, 0x89, 0x01, 0xb6, 0xdc, 0x2f, 0xe3, 0x73, 0xb5, + 0x9c, 0x16, 0x58, 0x32, 0x68, 0xa9, 0xc3, 0x30, 0x1f, 0x06, 0x03, 0x55, + 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xfd, 0xac, 0x61, 0x32, + 0x93, 0x6c, 0x45, 0xd6, 0xe2, 0xee, 0x85, 0x5f, 0x9a, 0xba, 0xe7, 0x76, + 0x99, 0x68, 0xcc, 0xe7, 0x30, 0x23, 0x06, 0x03, 0x55, 0x1d, 0x11, 0x04, + 0x1c, 0x30, 0x1a, 0x82, 0x0c, 0x2a, 0x2e, 0x77, 0x65, 0x62, 0x6b, 0x69, + 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x82, 0x0a, 0x77, 0x65, 0x62, 0x6b, 0x69, + 0x74, 0x2e, 0x6f, 0x72, 0x67}; // The signature algorithm is specified as the following ASN.1 structure: // AlgorithmIdentifier ::= SEQUENCE { // algorithm OBJECT IDENTIFIER, // parameters ANY DEFINED BY algorithm OPTIONAL } // - const uint8 signature_algorithm[15] = { - 0x30, 0x0d, // a SEQUENCE of length 13 (0xd) + const uint8_t signature_algorithm[15] = { + 0x30, 0x0d, // a SEQUENCE of length 13 (0xd) 0x06, 0x09, // an OBJECT IDENTIFIER of length 9 - // 1.2.840.113549.1.1.5 - sha1WithRSAEncryption - 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, - 0x05, 0x00, // a NULL of length 0 + // 1.2.840.113549.1.1.5 - sha1WithRSAEncryption + 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x05, 0x05, + 0x00, // a NULL of length 0 }; // RSA signature, a big integer in the big-endian byte order. - const uint8 signature[256] = { - 0x1e, 0x6a, 0xe7, 0xe0, 0x4f, 0xe7, 0x4d, 0xd0, 0x69, 0x7c, 0xf8, 0x8f, - 0x99, 0xb4, 0x18, 0x95, 0x36, 0x24, 0x0f, 0x0e, 0xa3, 0xea, 0x34, 0x37, - 0xf4, 0x7d, 0xd5, 0x92, 0x35, 0x53, 0x72, 0x76, 0x3f, 0x69, 0xf0, 0x82, - 0x56, 0xe3, 0x94, 0x7a, 0x1d, 0x1a, 0x81, 0xaf, 0x9f, 0xc7, 0x43, 0x01, - 0x64, 0xd3, 0x7c, 0x0d, 0xc8, 0x11, 0x4e, 0x4a, 0xe6, 0x1a, 0xc3, 0x01, - 0x74, 0xe8, 0x35, 0x87, 0x5c, 0x61, 0xaa, 0x8a, 0x46, 0x06, 0xbe, 0x98, - 0x95, 0x24, 0x9e, 0x01, 0xe3, 0xe6, 0xa0, 0x98, 0xee, 0x36, 0x44, 0x56, - 0x8d, 0x23, 0x9c, 0x65, 0xea, 0x55, 0x6a, 0xdf, 0x66, 0xee, 0x45, 0xe8, - 0xa0, 0xe9, 0x7d, 0x9a, 0xba, 0x94, 0xc5, 0xc8, 0xc4, 0x4b, 0x98, 0xff, - 0x9a, 0x01, 0x31, 0x6d, 0xf9, 0x2b, 0x58, 0xe7, 0xe7, 0x2a, 0xc5, 0x4d, - 0xbb, 0xbb, 0xcd, 0x0d, 0x70, 0xe1, 0xad, 0x03, 0xf5, 0xfe, 0xf4, 0x84, - 0x71, 0x08, 0xd2, 0xbc, 0x04, 0x7b, 0x26, 0x1c, 0xa8, 0x0f, 0x9c, 0xd8, - 0x12, 0x6a, 0x6f, 0x2b, 0x67, 0xa1, 0x03, 0x80, 0x9a, 0x11, 0x0b, 0xe9, - 0xe0, 0xb5, 0xb3, 0xb8, 0x19, 0x4e, 0x0c, 0xa4, 0xd9, 0x2b, 0x3b, 0xc2, - 0xca, 0x20, 0xd3, 0x0c, 0xa4, 0xff, 0x93, 0x13, 0x1f, 0xfc, 0xba, 0x94, - 0x93, 0x8c, 0x64, 0x15, 0x2e, 0x28, 0xa9, 0x55, 0x8c, 0x2c, 0x48, 0xd3, - 0xd3, 0xc1, 0x50, 0x69, 0x19, 0xe8, 0x34, 0xd3, 0xf1, 0x04, 0x9f, 0x0a, - 0x7a, 0x21, 0x87, 0xbf, 0xb9, 0x59, 0x37, 0x2e, 0xf4, 0x71, 0xa5, 0x3e, - 0xbe, 0xcd, 0x70, 0x83, 0x18, 0xf8, 0x8a, 0x72, 0x85, 0x45, 0x1f, 0x08, - 0x01, 0x6f, 0x37, 0xf5, 0x2b, 0x7b, 0xea, 0xb9, 0x8b, 0xa3, 0xcc, 0xfd, - 0x35, 0x52, 0xdd, 0x66, 0xde, 0x4f, 0x30, 0xc5, 0x73, 0x81, 0xb6, 0xe8, - 0x3c, 0xd8, 0x48, 0x8a - }; + const uint8_t signature[256] = { + 0x1e, 0x6a, 0xe7, 0xe0, 0x4f, 0xe7, 0x4d, 0xd0, 0x69, 0x7c, 0xf8, 0x8f, + 0x99, 0xb4, 0x18, 0x95, 0x36, 0x24, 0x0f, 0x0e, 0xa3, 0xea, 0x34, 0x37, + 0xf4, 0x7d, 0xd5, 0x92, 0x35, 0x53, 0x72, 0x76, 0x3f, 0x69, 0xf0, 0x82, + 0x56, 0xe3, 0x94, 0x7a, 0x1d, 0x1a, 0x81, 0xaf, 0x9f, 0xc7, 0x43, 0x01, + 0x64, 0xd3, 0x7c, 0x0d, 0xc8, 0x11, 0x4e, 0x4a, 0xe6, 0x1a, 0xc3, 0x01, + 0x74, 0xe8, 0x35, 0x87, 0x5c, 0x61, 0xaa, 0x8a, 0x46, 0x06, 0xbe, 0x98, + 0x95, 0x24, 0x9e, 0x01, 0xe3, 0xe6, 0xa0, 0x98, 0xee, 0x36, 0x44, 0x56, + 0x8d, 0x23, 0x9c, 0x65, 0xea, 0x55, 0x6a, 0xdf, 0x66, 0xee, 0x45, 0xe8, + 0xa0, 0xe9, 0x7d, 0x9a, 0xba, 0x94, 0xc5, 0xc8, 0xc4, 0x4b, 0x98, 0xff, + 0x9a, 0x01, 0x31, 0x6d, 0xf9, 0x2b, 0x58, 0xe7, 0xe7, 0x2a, 0xc5, 0x4d, + 0xbb, 0xbb, 0xcd, 0x0d, 0x70, 0xe1, 0xad, 0x03, 0xf5, 0xfe, 0xf4, 0x84, + 0x71, 0x08, 0xd2, 0xbc, 0x04, 0x7b, 0x26, 0x1c, 0xa8, 0x0f, 0x9c, 0xd8, + 0x12, 0x6a, 0x6f, 0x2b, 0x67, 0xa1, 0x03, 0x80, 0x9a, 0x11, 0x0b, 0xe9, + 0xe0, 0xb5, 0xb3, 0xb8, 0x19, 0x4e, 0x0c, 0xa4, 0xd9, 0x2b, 0x3b, 0xc2, + 0xca, 0x20, 0xd3, 0x0c, 0xa4, 0xff, 0x93, 0x13, 0x1f, 0xfc, 0xba, 0x94, + 0x93, 0x8c, 0x64, 0x15, 0x2e, 0x28, 0xa9, 0x55, 0x8c, 0x2c, 0x48, 0xd3, + 0xd3, 0xc1, 0x50, 0x69, 0x19, 0xe8, 0x34, 0xd3, 0xf1, 0x04, 0x9f, 0x0a, + 0x7a, 0x21, 0x87, 0xbf, 0xb9, 0x59, 0x37, 0x2e, 0xf4, 0x71, 0xa5, 0x3e, + 0xbe, 0xcd, 0x70, 0x83, 0x18, 0xf8, 0x8a, 0x72, 0x85, 0x45, 0x1f, 0x08, + 0x01, 0x6f, 0x37, 0xf5, 0x2b, 0x7b, 0xea, 0xb9, 0x8b, 0xa3, 0xcc, 0xfd, + 0x35, 0x52, 0xdd, 0x66, 0xde, 0x4f, 0x30, 0xc5, 0x73, 0x81, 0xb6, 0xe8, + 0x3c, 0xd8, 0x48, 0x8a}; // The public key is specified as the following ASN.1 structure: // SubjectPublicKeyInfo ::= SEQUENCE { // algorithm AlgorithmIdentifier, // subjectPublicKey BIT STRING } - const uint8 public_key_info[294] = { - 0x30, 0x82, 0x01, 0x22, // a SEQUENCE of length 290 (0x122) + const uint8_t public_key_info[294] = { + 0x30, 0x82, 0x01, 0x22, // a SEQUENCE of length 290 (0x122) // algorithm 0x30, 0x0d, // a SEQUENCE of length 13 - 0x06, 0x09, // an OBJECT IDENTIFIER of length 9 - 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, - 0x05, 0x00, // a NULL of length 0 + 0x06, 0x09, // an OBJECT IDENTIFIER of length 9 + 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, + 0x00, // a NULL of length 0 // subjectPublicKey 0x03, 0x82, 0x01, 0x0f, // a BIT STRING of length 271 (0x10f) - 0x00, // number of unused bits - 0x30, 0x82, 0x01, 0x0a, // a SEQUENCE of length 266 (0x10a) - // modulus - 0x02, 0x82, 0x01, 0x01, // an INTEGER of length 257 (0x101) - 0x00, 0xc4, 0x2d, 0xd5, 0x15, 0x8c, 0x9c, 0x26, 0x4c, 0xec, - 0x32, 0x35, 0xeb, 0x5f, 0xb8, 0x59, 0x01, 0x5a, 0xa6, 0x61, - 0x81, 0x59, 0x3b, 0x70, 0x63, 0xab, 0xe3, 0xdc, 0x3d, 0xc7, - 0x2a, 0xb8, 0xc9, 0x33, 0xd3, 0x79, 0xe4, 0x3a, 0xed, 0x3c, - 0x30, 0x23, 0x84, 0x8e, 0xb3, 0x30, 0x14, 0xb6, 0xb2, 0x87, - 0xc3, 0x3d, 0x95, 0x54, 0x04, 0x9e, 0xdf, 0x99, 0xdd, 0x0b, - 0x25, 0x1e, 0x21, 0xde, 0x65, 0x29, 0x7e, 0x35, 0xa8, 0xa9, - 0x54, 0xeb, 0xf6, 0xf7, 0x32, 0x39, 0xd4, 0x26, 0x55, 0x95, - 0xad, 0xef, 0xfb, 0xfe, 0x58, 0x86, 0xd7, 0x9e, 0xf4, 0x00, - 0x8d, 0x8c, 0x2a, 0x0c, 0xbd, 0x42, 0x04, 0xce, 0xa7, 0x3f, - 0x04, 0xf6, 0xee, 0x80, 0xf2, 0xaa, 0xef, 0x52, 0xa1, 0x69, - 0x66, 0xda, 0xbe, 0x1a, 0xad, 0x5d, 0xda, 0x2c, 0x66, 0xea, - 0x1a, 0x6b, 0xbb, 0xe5, 0x1a, 0x51, 0x4a, 0x00, 0x2f, 0x48, - 0xc7, 0x98, 0x75, 0xd8, 0xb9, 0x29, 0xc8, 0xee, 0xf8, 0x66, - 0x6d, 0x0a, 0x9c, 0xb3, 0xf3, 0xfc, 0x78, 0x7c, 0xa2, 0xf8, - 0xa3, 0xf2, 0xb5, 0xc3, 0xf3, 0xb9, 0x7a, 0x91, 0xc1, 0xa7, - 0xe6, 0x25, 0x2e, 0x9c, 0xa8, 0xed, 0x12, 0x65, 0x6e, 0x6a, - 0xf6, 0x12, 0x44, 0x53, 0x70, 0x30, 0x95, 0xc3, 0x9c, 0x2b, - 0x58, 0x2b, 0x3d, 0x08, 0x74, 0x4a, 0xf2, 0xbe, 0x51, 0xb0, - 0xbf, 0x87, 0xd0, 0x4c, 0x27, 0x58, 0x6b, 0xb5, 0x35, 0xc5, - 0x9d, 0xaf, 0x17, 0x31, 0xf8, 0x0b, 0x8f, 0xee, 0xad, 0x81, - 0x36, 0x05, 0x89, 0x08, 0x98, 0xcf, 0x3a, 0xaf, 0x25, 0x87, - 0xc0, 0x49, 0xea, 0xa7, 0xfd, 0x67, 0xf7, 0x45, 0x8e, 0x97, - 0xcc, 0x14, 0x39, 0xe2, 0x36, 0x85, 0xb5, 0x7e, 0x1a, 0x37, - 0xfd, 0x16, 0xf6, 0x71, 0x11, 0x9a, 0x74, 0x30, 0x16, 0xfe, - 0x13, 0x94, 0xa3, 0x3f, 0x84, 0x0d, 0x4f, - // public exponent - 0x02, 0x03, // an INTEGER of length 3 - 0x01, 0x00, 0x01 - }; + 0x00, // number of unused bits + 0x30, 0x82, 0x01, 0x0a, // a SEQUENCE of length 266 (0x10a) + // modulus + 0x02, 0x82, 0x01, 0x01, // an INTEGER of length 257 (0x101) + 0x00, 0xc4, 0x2d, 0xd5, 0x15, 0x8c, 0x9c, 0x26, 0x4c, 0xec, 0x32, 0x35, + 0xeb, 0x5f, 0xb8, 0x59, 0x01, 0x5a, 0xa6, 0x61, 0x81, 0x59, 0x3b, 0x70, + 0x63, 0xab, 0xe3, 0xdc, 0x3d, 0xc7, 0x2a, 0xb8, 0xc9, 0x33, 0xd3, 0x79, + 0xe4, 0x3a, 0xed, 0x3c, 0x30, 0x23, 0x84, 0x8e, 0xb3, 0x30, 0x14, 0xb6, + 0xb2, 0x87, 0xc3, 0x3d, 0x95, 0x54, 0x04, 0x9e, 0xdf, 0x99, 0xdd, 0x0b, + 0x25, 0x1e, 0x21, 0xde, 0x65, 0x29, 0x7e, 0x35, 0xa8, 0xa9, 0x54, 0xeb, + 0xf6, 0xf7, 0x32, 0x39, 0xd4, 0x26, 0x55, 0x95, 0xad, 0xef, 0xfb, 0xfe, + 0x58, 0x86, 0xd7, 0x9e, 0xf4, 0x00, 0x8d, 0x8c, 0x2a, 0x0c, 0xbd, 0x42, + 0x04, 0xce, 0xa7, 0x3f, 0x04, 0xf6, 0xee, 0x80, 0xf2, 0xaa, 0xef, 0x52, + 0xa1, 0x69, 0x66, 0xda, 0xbe, 0x1a, 0xad, 0x5d, 0xda, 0x2c, 0x66, 0xea, + 0x1a, 0x6b, 0xbb, 0xe5, 0x1a, 0x51, 0x4a, 0x00, 0x2f, 0x48, 0xc7, 0x98, + 0x75, 0xd8, 0xb9, 0x29, 0xc8, 0xee, 0xf8, 0x66, 0x6d, 0x0a, 0x9c, 0xb3, + 0xf3, 0xfc, 0x78, 0x7c, 0xa2, 0xf8, 0xa3, 0xf2, 0xb5, 0xc3, 0xf3, 0xb9, + 0x7a, 0x91, 0xc1, 0xa7, 0xe6, 0x25, 0x2e, 0x9c, 0xa8, 0xed, 0x12, 0x65, + 0x6e, 0x6a, 0xf6, 0x12, 0x44, 0x53, 0x70, 0x30, 0x95, 0xc3, 0x9c, 0x2b, + 0x58, 0x2b, 0x3d, 0x08, 0x74, 0x4a, 0xf2, 0xbe, 0x51, 0xb0, 0xbf, 0x87, + 0xd0, 0x4c, 0x27, 0x58, 0x6b, 0xb5, 0x35, 0xc5, 0x9d, 0xaf, 0x17, 0x31, + 0xf8, 0x0b, 0x8f, 0xee, 0xad, 0x81, 0x36, 0x05, 0x89, 0x08, 0x98, 0xcf, + 0x3a, 0xaf, 0x25, 0x87, 0xc0, 0x49, 0xea, 0xa7, 0xfd, 0x67, 0xf7, 0x45, + 0x8e, 0x97, 0xcc, 0x14, 0x39, 0xe2, 0x36, 0x85, 0xb5, 0x7e, 0x1a, 0x37, + 0xfd, 0x16, 0xf6, 0x71, 0x11, 0x9a, 0x74, 0x30, 0x16, 0xfe, 0x13, 0x94, + 0xa3, 0x3f, 0x84, 0x0d, 0x4f, + // public exponent + 0x02, 0x03, // an INTEGER of length 3 + 0x01, 0x00, 0x01}; // We use the signature verifier to perform four signature verification // tests. @@ -230,7 +227,7 @@ TEST(SignatureVerifierTest, BasicTest) { EXPECT_TRUE(ok); // Test 3: verify the signature with incorrect data. - uint8 bad_tbs_certificate[sizeof(tbs_certificate)]; + uint8_t bad_tbs_certificate[sizeof(tbs_certificate)]; memcpy(bad_tbs_certificate, tbs_certificate, sizeof(tbs_certificate)); bad_tbs_certificate[10] += 1; // Corrupt one byte of the data. ok = verifier.VerifyInit(signature_algorithm, @@ -243,7 +240,7 @@ TEST(SignatureVerifierTest, BasicTest) { EXPECT_FALSE(ok); // Test 4: verify a bad signature. - uint8 bad_signature[sizeof(signature)]; + uint8_t bad_signature[sizeof(signature)]; memcpy(bad_signature, signature, sizeof(signature)); bad_signature[10] += 1; // Corrupt one byte of the signature. ok = verifier.VerifyInit(signature_algorithm, @@ -980,7 +977,7 @@ static const PSSTestVector pss_test[] = { }, }; -static uint8 HexDigitValue(char digit) { +static uint8_t HexDigitValue(char digit) { if ('0' <= digit && digit <= '9') return digit - '0'; if ('a' <= digit && digit <= 'f') @@ -988,12 +985,12 @@ static uint8 HexDigitValue(char digit) { return digit - 'A' + 10; } -static bool DecodeTestInput(const char* in, std::vector<uint8>* out) { +static bool DecodeTestInput(const char* in, std::vector<uint8_t>* out) { out->clear(); while (in[0] != '\0') { if (!isxdigit(in[0]) || !isxdigit(in[1]) || in[2] != ' ') return false; - uint8 octet = HexDigitValue(in[0]) * 16 + HexDigitValue(in[1]); + uint8_t octet = HexDigitValue(in[0]) * 16 + HexDigitValue(in[1]); out->push_back(octet); in += 3; } @@ -1002,24 +999,24 @@ static bool DecodeTestInput(const char* in, std::vector<uint8>* out) { // PrependASN1Length prepends an ASN.1 serialized length to the beginning of // |out|. -static void PrependASN1Length(std::vector<uint8>* out, size_t len) { +static void PrependASN1Length(std::vector<uint8_t>* out, size_t len) { if (len < 128) { - out->insert(out->begin(), static_cast<uint8>(len)); + out->insert(out->begin(), static_cast<uint8_t>(len)); } else if (len < 256) { - out->insert(out->begin(), static_cast<uint8>(len)); + out->insert(out->begin(), static_cast<uint8_t>(len)); out->insert(out->begin(), 0x81); } else if (len < 0x10000) { - out->insert(out->begin(), static_cast<uint8>(len)); - out->insert(out->begin(), static_cast<uint8>(len >> 8)); + out->insert(out->begin(), static_cast<uint8_t>(len)); + out->insert(out->begin(), static_cast<uint8_t>(len >> 8)); out->insert(out->begin(), 0x82); } else { CHECK(false) << "ASN.1 length not handled: " << len; } } -static bool EncodeRSAPublicKey(const std::vector<uint8>& modulus_n, - const std::vector<uint8>& public_exponent_e, - std::vector<uint8>* public_key_info) { +static bool EncodeRSAPublicKey(const std::vector<uint8_t>& modulus_n, + const std::vector<uint8_t>& public_exponent_e, + std::vector<uint8_t>* public_key_info) { // The public key is specified as the following ASN.1 structure: // SubjectPublicKeyInfo ::= SEQUENCE { // algorithm AlgorithmIdentifier, @@ -1035,9 +1032,9 @@ static bool EncodeRSAPublicKey(const std::vector<uint8>& modulus_n, // modulus INTEGER, -- n // publicExponent INTEGER -- e // } - static const uint8 kIntegerTag = 0x02; - static const uint8 kBitStringTag = 0x03; - static const uint8 kSequenceTag = 0x30; + static const uint8_t kIntegerTag = 0x02; + static const uint8_t kBitStringTag = 0x03; + static const uint8_t kSequenceTag = 0x30; public_key_info->clear(); // Encode the public exponent e as an INTEGER. @@ -1069,11 +1066,10 @@ static bool EncodeRSAPublicKey(const std::vector<uint8>& modulus_n, public_key_info->insert(public_key_info->begin(), kBitStringTag); // Encode the AlgorithmIdentifier. - static const uint8 algorithm[] = { - 0x30, 0x0d, // a SEQUENCE of length 13 + static const uint8_t algorithm[] = { + 0x30, 0x0d, // a SEQUENCE of length 13 0x06, 0x09, // an OBJECT IDENTIFIER of length 9 - 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, - 0x05, 0x00, + 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, }; public_key_info->insert(public_key_info->begin(), algorithm, algorithm + sizeof(algorithm)); @@ -1088,20 +1084,20 @@ static bool EncodeRSAPublicKey(const std::vector<uint8>& modulus_n, TEST(SignatureVerifierTest, VerifyRSAPSS) { for (unsigned int i = 0; i < arraysize(pss_test); i++) { SCOPED_TRACE(i); - std::vector<uint8> modulus_n; - std::vector<uint8> public_exponent_e; + std::vector<uint8_t> modulus_n; + std::vector<uint8_t> public_exponent_e; ASSERT_TRUE(DecodeTestInput(pss_test[i].modulus_n, &modulus_n)); ASSERT_TRUE(DecodeTestInput(pss_test[i].public_exponent_e, &public_exponent_e)); - std::vector<uint8> public_key_info; + std::vector<uint8_t> public_key_info; ASSERT_TRUE(EncodeRSAPublicKey(modulus_n, public_exponent_e, &public_key_info)); for (unsigned int j = 0; j < arraysize(pss_test[i].example); j++) { SCOPED_TRACE(j); - std::vector<uint8> message; - std::vector<uint8> salt; - std::vector<uint8> signature; + std::vector<uint8_t> message; + std::vector<uint8_t> salt; + std::vector<uint8_t> signature; ASSERT_TRUE(DecodeTestInput(pss_test[i].example[j].message, &message)); ASSERT_TRUE(DecodeTestInput(pss_test[i].example[j].salt, &salt)); ASSERT_TRUE(DecodeTestInput(pss_test[i].example[j].signature, diff --git a/crypto/symmetric_key.h b/crypto/symmetric_key.h index 996c592..14f74ae 100644 --- a/crypto/symmetric_key.h +++ b/crypto/symmetric_key.h @@ -5,9 +5,12 @@ #ifndef CRYPTO_SYMMETRIC_KEY_H_ #define CRYPTO_SYMMETRIC_KEY_H_ +#include <stddef.h> + #include <string> -#include "base/basictypes.h" +#include "base/macros.h" +#include "build/build_config.h" #include "crypto/crypto_export.h" #if defined(NACL_WIN64) diff --git a/crypto/symmetric_key_nss.cc b/crypto/symmetric_key_nss.cc index 95ca9bd..e3aacc7 100644 --- a/crypto/symmetric_key_nss.cc +++ b/crypto/symmetric_key_nss.cc @@ -6,9 +6,11 @@ #include <nss.h> #include <pk11pub.h> +#include <stddef.h> #include "base/logging.h" #include "crypto/nss_util.h" +#include "crypto/scoped_nss_types.h" namespace crypto { diff --git a/crypto/symmetric_key_openssl.cc b/crypto/symmetric_key_openssl.cc index 912c9b4..2c5358f 100644 --- a/crypto/symmetric_key_openssl.cc +++ b/crypto/symmetric_key_openssl.cc @@ -6,6 +6,8 @@ #include <openssl/evp.h> #include <openssl/rand.h> +#include <stddef.h> +#include <stdint.h> #include <algorithm> @@ -39,7 +41,7 @@ SymmetricKey* SymmetricKey::GenerateRandomKey(Algorithm algorithm, OpenSSLErrStackTracer err_tracer(FROM_HERE); scoped_ptr<SymmetricKey> key(new SymmetricKey); - uint8* key_data = reinterpret_cast<uint8*>( + uint8_t* key_data = reinterpret_cast<uint8_t*>( base::WriteInto(&key->key_, key_size_in_bytes + 1)); int rv = RAND_bytes(key_data, static_cast<int>(key_size_in_bytes)); @@ -70,13 +72,12 @@ SymmetricKey* SymmetricKey::DeriveKeyFromPassword(Algorithm algorithm, OpenSSLErrStackTracer err_tracer(FROM_HERE); scoped_ptr<SymmetricKey> key(new SymmetricKey); - uint8* key_data = reinterpret_cast<uint8*>( + uint8_t* key_data = reinterpret_cast<uint8_t*>( base::WriteInto(&key->key_, key_size_in_bytes + 1)); - int rv = PKCS5_PBKDF2_HMAC_SHA1(password.data(), password.length(), - reinterpret_cast<const uint8*>(salt.data()), - salt.length(), iterations, - static_cast<int>(key_size_in_bytes), - key_data); + int rv = PKCS5_PBKDF2_HMAC_SHA1( + password.data(), password.length(), + reinterpret_cast<const uint8_t*>(salt.data()), salt.length(), iterations, + static_cast<int>(key_size_in_bytes), key_data); return rv == 1 ? key.release() : NULL; } diff --git a/crypto/symmetric_key_win.cc b/crypto/symmetric_key_win.cc index efc7fe4..ac8e614 100644 --- a/crypto/symmetric_key_win.cc +++ b/crypto/symmetric_key_win.cc @@ -4,6 +4,9 @@ #include "crypto/symmetric_key.h" +#include <stddef.h> +#include <stdint.h> + #include <vector> // TODO(wtc): replace scoped_array by std::vector. @@ -239,7 +242,7 @@ bool ComputePBKDF2Block(HCRYPTHASH hash, DWORD hash_size, const std::string& salt, size_t iterations, - uint32 block_index, + uint32_t block_index, BYTE* output_buf) { // From RFC 2898: // 3. <snip> The function F is defined as the exclusive-or sum of the first @@ -263,7 +266,7 @@ bool ComputePBKDF2Block(HCRYPTHASH hash, return false; // Iteration U_1: and append (big-endian) INT (i). - uint32 big_endian_block_index = base::HostToNet32(block_index); + uint32_t big_endian_block_index = base::HostToNet32(block_index); ok = CryptHashData(safe_hash, reinterpret_cast<BYTE*>(&big_endian_block_index), sizeof(big_endian_block_index), 0); @@ -440,7 +443,7 @@ SymmetricKey* SymmetricKey::DeriveKeyFromPassword(Algorithm algorithm, // 4. Concatenate the blocks and extract the first dkLen octets to produce // a derived key DK: // DK = T_1 || T_2 || ... || T_l<0..r-1> - for (uint32 block_index = 1; block_index <= L; ++block_index) { + for (uint32_t block_index = 1; block_index <= L; ++block_index) { if (!ComputePBKDF2Block(prf, hLen, salt, iterations, block_index, block_offset)) return NULL; diff --git a/crypto/third_party/nss/secsign.cc b/crypto/third_party/nss/secsign.cc index a788def..c9816fb0 100644 --- a/crypto/third_party/nss/secsign.cc +++ b/crypto/third_party/nss/secsign.cc @@ -46,8 +46,8 @@ #include <pk11pub.h> #include <secerr.h> #include <sechash.h> +#include <stdint.h> -#include "base/basictypes.h" #include "base/logging.h" #include "build/build_config.h" @@ -88,7 +88,7 @@ SECStatus DerSignData(PLArenaPool *arena, } // Hash the input. - std::vector<uint8> hash_data(HASH_ResultLen(hash_type)); + std::vector<uint8_t> hash_data(HASH_ResultLen(hash_type)); SECStatus rv = HASH_HashBuf( hash_type, &hash_data[0], input->data, input->len); if (rv != SECSuccess) @@ -98,7 +98,7 @@ SECStatus DerSignData(PLArenaPool *arena, // Compute signature of hash. int signature_len = PK11_SignatureLen(key); - std::vector<uint8> signature_data(signature_len); + std::vector<uint8_t> signature_data(signature_len); SECItem sig = {siBuffer, &signature_data[0], static_cast<unsigned int>(signature_len)}; rv = PK11_Sign(key, &sig, &hash); |