1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109


content / browser / sms / sms_parser.cc [blame]

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

#include "content/browser/sms/sms_parser.h"

#include <string>
#include <string_view>
#include <utility>

#include "net/base/url_util.h"
#include "third_party/re2/src/re2/re2.h"
#include "url/gurl.h"
#include "url/origin.h"

namespace content {

namespace {

// SMS one-time-passcode format:
// https://wicg.github.io/sms-one-time-codes/#parsing
constexpr char kOtpFormatRegex[] =
    "(?:^|\\s)"                 // Leading characters
    "@([a-zA-Z0-9.-]+) "        // Domain
    "#([^#\\s]+)"               // OTP
    "(?: @([a-zA-Z0-9.-]+))?";  // Optional domain

using SmsParsingStatus = SmsParser::SmsParsingStatus;
using ParseDomainResult = std::tuple<SmsParsingStatus, GURL>;

ParseDomainResult ParseDomain(const std::string& domain) {
  std::string host, scheme;
  int port;
  if (!net::ParseHostAndPort(domain, &host, &port))
    return std::make_tuple(SmsParsingStatus::kHostAndPortNotParsed, GURL());

  // Expect localhost to always be http.
  if (net::HostStringIsLocalhost(std::string_view(host))) {
    scheme = "http://";
  } else {
    scheme = "https://";
  }

  GURL gurl = GURL(scheme + domain);

  if (!gurl.is_valid())
    return std::make_tuple(SmsParsingStatus::kGURLNotValid, GURL());

  return std::make_tuple(SmsParsingStatus::kParsed, gurl);
}
}  // namespace

SmsParser::Result::Result(SmsParsingStatus status) : parsing_status(status) {
  DCHECK(parsing_status != SmsParsingStatus::kParsed);
}
SmsParser::Result::Result(const url::Origin& top_origin,
                          const url::Origin& embedded_origin,
                          const std::string& one_time_code)
    : top_origin(std::move(top_origin)),
      embedded_origin(std::move(embedded_origin)),
      one_time_code(one_time_code) {
  parsing_status = SmsParsingStatus::kParsed;
}

SmsParser::Result::Result(const Result& other) = default;
SmsParser::Result::~Result() = default;

OriginList SmsParser::Result::GetOriginList() const {
  DCHECK(IsValid());
  OriginList origin_list;
  if (!embedded_origin.opaque())
    origin_list.push_back(embedded_origin);
  origin_list.push_back(top_origin);
  return origin_list;
}

// static
SmsParser::Result SmsParser::Parse(std::string_view sms) {
  std::string top_domain, otp, embedded_domain;
  // TODO(yigu): The existing kOtpFormatRegex may filter out invalid SMSes that
  // would fall into |kHostAndPortNotParsed| or |kGURLNotValid| below. We should
  // clean up the code if the statement is confirmed by metrics.
  if (!re2::RE2::PartialMatch(std::string(sms), kOtpFormatRegex, &top_domain,
                              &otp, &embedded_domain))
    return Result(SmsParsingStatus::kOTPFormatRegexNotMatch);

  auto [top_domain_parsing_status, top_gurl] = ParseDomain(top_domain);
  if (top_domain_parsing_status != SmsParsingStatus::kParsed)
    return Result(top_domain_parsing_status);
  DCHECK(top_gurl.is_valid());

  url::Origin top_origin = url::Origin::Create(top_gurl);
  DCHECK(!top_origin.opaque());

  if (embedded_domain == "")
    return Result(top_origin, url::Origin(), otp);

  auto [embedded_domain_parsing_status, embedded_gurl] =
      ParseDomain(embedded_domain);
  if (embedded_domain_parsing_status != SmsParsingStatus::kParsed)
    return Result(embedded_domain_parsing_status);
  DCHECK(embedded_gurl.is_valid());

  url::Origin embedded_origin = url::Origin::Create(embedded_gurl);
  DCHECK(!embedded_origin.opaque());
  return Result(top_origin, embedded_origin, otp);
}

}  // namespace content