internal_auth.cc | Explore in Territory

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/internal_auth.h"

#include <stddef.h>
#include <stdint.h>

#include <algorithm>
#include <limits>
#include <memory>

#include "base/base64.h"
#include "base/check.h"
#include "base/containers/circular_deque.h"
#include "base/containers/contains.h"
#include "base/lazy_instance.h"
#include "base/notreached.h"
#include "base/rand_util.h"
#include "base/ranges/algorithm.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/synchronization/lock.h"
#include "base/threading/thread_checker.h"
#include "base/time/time.h"
#include "base/values.h"
#include "crypto/hmac.h"

namespace {

VarValueMap;

// Size of a tick in microseconds. This determines upper bound for average
// number of passports generated per time unit. This bound equals to
// (kMicrosecondsPerSecond / TickUs) calls per second.
const int64_t kTickUs = …;

// Verification window size in ticks; that means any passport expires in
// (kVerificationWindowTicks * TickUs / kMicrosecondsPerSecond) seconds.
const int kVerificationWindowTicks = …;

// Generation window determines how well we are able to cope with bursts of
// GeneratePassport calls those exceed upper bound on average speed.
const int kGenerationWindowTicks = …;

// Makes no sense to compare other way round.
static_assert …;
// We are not optimized for high value of kGenerationWindowTicks.
static_assert …;

// Regenerate key after this number of ticks.
const int kKeyRegenerationSoftTicks = …;
// Reject passports if key has not been regenerated in that number of ticks.
const int kKeyRegenerationHardTicks = …;

// Limit for number of accepted var=value pairs. Feel free to bump this limit
// higher once needed.
const size_t kVarsLimit = …;

// Limit for length of caller-supplied strings. Feel free to bump this limit
// higher once needed.
const size_t kStringLengthLimit = …;

// Character used as a separator for construction of message to take HMAC of.
// It is critical to validate all caller-supplied data (used to construct
// message) to be clear of this separator because it could allow attacks.
const char kItemSeparator = …;

// Character used for var=value separation.
const char kVarValueSeparator = …;

const size_t kKeySizeInBytes = …;
const size_t kHMACSizeInBytes = …;

// Length of base64 string required to encode given number of raw octets.
#define BASE64_PER_RAW(X) …

// Size of decimal string representing 64-bit tick.
const size_t kTickStringLength = …;

// A passport consists of 2 parts: HMAC and tick.
const size_t kPassportSize = …;

int64_t GetCurrentTick() { … }

bool IsDomainSane(const std::string& domain) { … }

bool IsVarSane(const std::string& var) { … }

bool IsValueSane(const std::string& value) { … }

bool IsVarValueMapSane(const VarValueMap& map) { … }

void ConvertVarValueMapToBlob(const VarValueMap& map, std::string* out) { … }

void CreatePassport(const std::string& domain,
                    const VarValueMap& map,
                    int64_t tick,
                    const crypto::HMAC* engine,
                    std::string* out) { … }

}  // namespace

class InternalAuthVerificationService { … };

namespace {

static base::LazyInstance<InternalAuthVerificationService>::DestructorAtExit
    g_verification_service = …;
static base::LazyInstance<base::Lock>::Leaky
    g_verification_service_lock = …;

}  // namespace

class InternalAuthGenerationService : public base::ThreadChecker { … };

namespace {

static base::LazyInstance<InternalAuthGenerationService>::DestructorAtExit
    g_generation_service = …;

}  // namespace

// static
bool InternalAuthVerification::VerifyPassport(
    const std::string& passport,
    const std::string& domain,
    const VarValueMap& var_value_map) { … }

// static
void InternalAuthVerification::ChangeKey(const std::string& key) { … }

// static
int InternalAuthVerification::get_verification_window_ticks() { … }

int InternalAuthVerification::verification_window_seconds_ = …;

// static
std::string InternalAuthGeneration::GeneratePassport(
    const std::string& domain, const VarValueMap& var_value_map) { … }

// static
void InternalAuthGeneration::GenerateNewKey() { … }
chromium/chrome/browser/internal_auth.cc
