src/content/child/webcrypto/status.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/child/webcrypto/status.h"
   6
   7 namespace content {
   8
   9 namespace webcrypto {
  10
  11 bool Status::IsError() const {
  12   return type_ == TYPE_ERROR;
  13 }
  14
  15 bool Status::IsSuccess() const {
  16   return type_ == TYPE_SUCCESS;
  17 }
  18
  19 Status Status::Success() {
  20   return Status(TYPE_SUCCESS);
  21 }
  22
  23 Status Status::OperationError() {
  24   return Status(blink::WebCryptoErrorTypeOperation, "");
  25 }
  26
  27 Status Status::DataError() {
  28   return Status(blink::WebCryptoErrorTypeData, "");
  29 }
  30
  31 Status Status::ErrorJwkNotDictionary() {
  32   return Status(blink::WebCryptoErrorTypeData,
  33                 "JWK input could not be parsed to a JSON dictionary");
  34 }
  35
  36 Status Status::ErrorJwkPropertyMissing(const std::string& property) {
  37   return Status(blink::WebCryptoErrorTypeData,
  38                 "The required JWK property \"" + property + "\" was missing");
  39 }
  40
  41 Status Status::ErrorJwkPropertyWrongType(const std::string& property,
  42                                          const std::string& expected_type) {
  43   return Status(
  44       blink::WebCryptoErrorTypeData,
  45       "The JWK property \"" + property + "\" must be a " + expected_type);
  46 }
  47
  48 Status Status::ErrorJwkBase64Decode(const std::string& property) {
  49   return Status(
  50       blink::WebCryptoErrorTypeData,
  51       "The JWK property \"" + property + "\" could not be base64 decoded");
  52 }
  53
  54 Status Status::ErrorJwkExtInconsistent() {
  55   return Status(
  56       blink::WebCryptoErrorTypeData,
  57       "The \"ext\" property of the JWK dictionary is inconsistent what that "
  58       "specified by the Web Crypto call");
  59 }
  60
  61 Status Status::ErrorJwkAlgorithmInconsistent() {
  62   return Status(blink::WebCryptoErrorTypeData,
  63                 "The JWK \"alg\" property was inconsistent with that specified "
  64                 "by the Web Crypto call");
  65 }
  66
  67 Status Status::ErrorJwkUnrecognizedUse() {
  68   return Status(blink::WebCryptoErrorTypeData,
  69                 "The JWK \"use\" property could not be parsed");
  70 }
  71
  72 Status Status::ErrorJwkUnrecognizedKeyop() {
  73   return Status(blink::WebCryptoErrorTypeData,
  74                 "The JWK \"key_ops\" property could not be parsed");
  75 }
  76
  77 Status Status::ErrorJwkUseInconsistent() {
  78   return Status(blink::WebCryptoErrorTypeData,
  79                 "The JWK \"use\" property was inconsistent with that specified "
  80                 "by the Web Crypto call. The JWK usage must be a superset of "
  81                 "those requested");
  82 }
  83
  84 Status Status::ErrorJwkKeyopsInconsistent() {
  85   return Status(blink::WebCryptoErrorTypeData,
  86                 "The JWK \"key_ops\" property was inconsistent with that "
  87                 "specified by the Web Crypto call. The JWK usage must be a "
  88                 "superset of those requested");
  89 }
  90
  91 Status Status::ErrorJwkUseAndKeyopsInconsistent() {
  92   return Status(blink::WebCryptoErrorTypeData,
  93                 "The JWK \"use\" and \"key_ops\" properties were both found "
  94                 "but are inconsistent with each other.");
  95 }
  96
  97 Status Status::ErrorJwkUnexpectedKty(const std::string& expected) {
  98   return Status(blink::WebCryptoErrorTypeData,
  99                 "The JWK \"kty\" property was not \"" + expected + "\"");
 100 }
 101
 102 Status Status::ErrorJwkIncorrectKeyLength() {
 103   return Status(blink::WebCryptoErrorTypeData,
 104                 "The JWK \"k\" property did not include the right length "
 105                 "of key data for the given algorithm.");
 106 }
 107
 108 Status Status::ErrorJwkEmptyBigInteger(const std::string& property) {
 109   return Status(blink::WebCryptoErrorTypeData,
 110                 "The JWK \"" + property + "\" property was empty.");
 111 }
 112
 113 Status Status::ErrorJwkBigIntegerHasLeadingZero(const std::string& property) {
 114   return Status(
 115       blink::WebCryptoErrorTypeData,
 116       "The JWK \"" + property + "\" property contained a leading zero.");
 117 }
 118
 119 Status Status::ErrorImportEmptyKeyData() {
 120   return Status(blink::WebCryptoErrorTypeData, "No key data was provided");
 121 }
 122
 123 Status Status::ErrorUnsupportedImportKeyFormat() {
 124   return Status(blink::WebCryptoErrorTypeNotSupported,
 125                 "Unsupported import key format for algorithm");
 126 }
 127
 128 Status Status::ErrorUnsupportedExportKeyFormat() {
 129   return Status(blink::WebCryptoErrorTypeNotSupported,
 130                 "Unsupported export key format for algorithm");
 131 }
 132
 133 Status Status::ErrorImportAesKeyLength() {
 134   return Status(blink::WebCryptoErrorTypeData,
 135                 "AES key data must be 128, 192 or 256 bits");
 136 }
 137
 138 Status Status::ErrorAes192BitUnsupported() {
 139   return Status(blink::WebCryptoErrorTypeNotSupported,
 140                 "192-bit AES keys are not supported");
 141 }
 142
 143 Status Status::ErrorUnexpectedKeyType() {
 144   return Status(blink::WebCryptoErrorTypeInvalidAccess,
 145                 "The key is not of the expected type");
 146 }
 147
 148 Status Status::ErrorIncorrectSizeAesCbcIv() {
 149   return Status(blink::WebCryptoErrorTypeData,
 150                 "The \"iv\" has an unexpected length -- must be 16 bytes");
 151 }
 152
 153 Status Status::ErrorDataTooLarge() {
 154   return Status(blink::WebCryptoErrorTypeData,
 155                 "The provided data is too large");
 156 }
 157
 158 Status Status::ErrorDataTooSmall() {
 159   return Status(blink::WebCryptoErrorTypeData,
 160                 "The provided data is too small");
 161 }
 162
 163 Status Status::ErrorUnsupported() {
 164   return ErrorUnsupported("The requested operation is unsupported");
 165 }
 166
 167 Status Status::ErrorUnsupported(const std::string& message) {
 168   return Status(blink::WebCryptoErrorTypeNotSupported, message);
 169 }
 170
 171 Status Status::ErrorUnexpected() {
 172   return Status(blink::WebCryptoErrorTypeUnknown,
 173                 "Something unexpected happened...");
 174 }
 175
 176 Status Status::ErrorInvalidAesGcmTagLength() {
 177   return Status(
 178       blink::WebCryptoErrorTypeData,
 179       "The tag length is invalid: Must be 32, 64, 96, 104, 112, 120, or 128 "
 180       "bits");
 181 }
 182
 183 Status Status::ErrorInvalidAesKwDataLength() {
 184   return Status(blink::WebCryptoErrorTypeData,
 185                 "The AES-KW input data length is invalid: not a multiple of 8 "
 186                 "bytes");
 187 }
 188
 189 Status Status::ErrorGenerateKeyPublicExponent() {
 190   return Status(blink::WebCryptoErrorTypeData,
 191                 "The \"publicExponent\" must be either 3 or 65537");
 192 }
 193
 194 Status Status::ErrorImportRsaEmptyModulus() {
 195   return Status(blink::WebCryptoErrorTypeData, "The modulus is empty");
 196 }
 197
 198 Status Status::ErrorGenerateRsaUnsupportedModulus() {
 199   return Status(blink::WebCryptoErrorTypeNotSupported,
 200                 "The modulus length must be a multiple of 8 bits and >= 256 "
 201                 "and <= 16384");
 202 }
 203
 204 Status Status::ErrorImportRsaEmptyExponent() {
 205   return Status(blink::WebCryptoErrorTypeData,
 206                 "No bytes for the exponent were provided");
 207 }
 208
 209 Status Status::ErrorKeyNotExtractable() {
 210   return Status(blink::WebCryptoErrorTypeInvalidAccess,
 211                 "They key is not extractable");
 212 }
 213
 214 Status Status::ErrorGenerateKeyLength() {
 215   return Status(blink::WebCryptoErrorTypeData,
 216                 "Invalid key length: it is either zero or not a multiple of 8 "
 217                 "bits");
 218 }
 219
 220 Status Status::ErrorCreateKeyBadUsages() {
 221   return Status(blink::WebCryptoErrorTypeData,
 222                 "Cannot create a key using the specified key usages.");
 223 }
 224
 225 Status::Status(blink::WebCryptoErrorType error_type,
 226                const std::string& error_details_utf8)
 227     : type_(TYPE_ERROR),
 228       error_type_(error_type),
 229       error_details_(error_details_utf8) {
 230 }
 231
 232 Status::Status(Type type) : type_(type) {
 233 }
 234
 235 }  // namespace webcrypto
 236
 237 }  // namespace content