components/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 "components/webcrypto/status.h"
   6
   7 #include "base/format_macros.h"
   8 #include "base/strings/stringprintf.h"
   9
  10 namespace webcrypto {
  11
  12 bool Status::IsError() const {
  13   return type_ == TYPE_ERROR;
  14 }
  15
  16 bool Status::IsSuccess() const {
  17   return type_ == TYPE_SUCCESS;
  18 }
  19
  20 Status Status::Success() {
  21   return Status(TYPE_SUCCESS);
  22 }
  23
  24 Status Status::OperationError() {
  25   return Status(blink::WebCryptoErrorTypeOperation, "");
  26 }
  27
  28 Status Status::DataError() {
  29   return Status(blink::WebCryptoErrorTypeData, "");
  30 }
  31
  32 Status Status::ErrorJwkNotDictionary() {
  33   return Status(blink::WebCryptoErrorTypeData,
  34                 "JWK input could not be parsed to a JSON dictionary");
  35 }
  36
  37 Status Status::ErrorJwkMemberMissing(const std::string& member_name) {
  38   return Status(blink::WebCryptoErrorTypeData,
  39                 "The required JWK member \"" + member_name + "\" was missing");
  40 }
  41
  42 Status Status::ErrorJwkMemberWrongType(const std::string& member_name,
  43                                        const std::string& expected_type) {
  44   return Status(
  45       blink::WebCryptoErrorTypeData,
  46       "The JWK member \"" + member_name + "\" must be a " + expected_type);
  47 }
  48
  49 Status Status::ErrorJwkBase64Decode(const std::string& member_name) {
  50   return Status(blink::WebCryptoErrorTypeData,
  51                 "The JWK member \"" + member_name +
  52                     "\" could not be base64url decoded or contained padding");
  53 }
  54
  55 Status Status::ErrorJwkExtInconsistent() {
  56   return Status(
  57       blink::WebCryptoErrorTypeData,
  58       "The \"ext\" member of the JWK dictionary is inconsistent what that "
  59       "specified by the Web Crypto call");
  60 }
  61
  62 Status Status::ErrorJwkAlgorithmInconsistent() {
  63   return Status(blink::WebCryptoErrorTypeData,
  64                 "The JWK \"alg\" member was inconsistent with that specified "
  65                 "by the Web Crypto call");
  66 }
  67
  68 Status Status::ErrorJwkUnrecognizedUse() {
  69   return Status(blink::WebCryptoErrorTypeData,
  70                 "The JWK \"use\" member could not be parsed");
  71 }
  72
  73 Status Status::ErrorJwkUnrecognizedKeyop() {
  74   return Status(blink::WebCryptoErrorTypeData,
  75                 "The JWK \"key_ops\" member could not be parsed");
  76 }
  77
  78 Status Status::ErrorJwkUseInconsistent() {
  79   return Status(blink::WebCryptoErrorTypeData,
  80                 "The JWK \"use\" member was inconsistent with that specified "
  81                 "by the Web Crypto call. The JWK usage must be a superset of "
  82                 "those requested");
  83 }
  84
  85 Status Status::ErrorJwkKeyopsInconsistent() {
  86   return Status(blink::WebCryptoErrorTypeData,
  87                 "The JWK \"key_ops\" member was inconsistent with that "
  88                 "specified by the Web Crypto call. The JWK usage must be a "
  89                 "superset of those requested");
  90 }
  91
  92 Status Status::ErrorJwkUseAndKeyopsInconsistent() {
  93   return Status(blink::WebCryptoErrorTypeData,
  94                 "The JWK \"use\" and \"key_ops\" properties were both found "
  95                 "but are inconsistent with each other.");
  96 }
  97
  98 Status Status::ErrorJwkUnexpectedKty(const std::string& expected) {
  99   return Status(blink::WebCryptoErrorTypeData,
 100                 "The JWK \"kty\" member was not \"" + expected + "\"");
 101 }
 102
 103 Status Status::ErrorJwkIncorrectKeyLength() {
 104   return Status(blink::WebCryptoErrorTypeData,
 105                 "The JWK \"k\" member did not include the right length "
 106                 "of key data for the given algorithm.");
 107 }
 108
 109 Status Status::ErrorJwkEmptyBigInteger(const std::string& member_name) {
 110   return Status(blink::WebCryptoErrorTypeData,
 111                 "The JWK \"" + member_name + "\" member was empty.");
 112 }
 113
 114 Status Status::ErrorJwkBigIntegerHasLeadingZero(
 115     const std::string& member_name) {
 116   return Status(
 117       blink::WebCryptoErrorTypeData,
 118       "The JWK \"" + member_name + "\" member contained a leading zero.");
 119 }
 120
 121 Status Status::ErrorJwkDuplicateKeyOps() {
 122   return Status(blink::WebCryptoErrorTypeData,
 123                 "The \"key_ops\" member of the JWK dictionary contains "
 124                 "duplicate usages.");
 125 }
 126
 127 Status Status::ErrorUnsupportedImportKeyFormat() {
 128   return Status(blink::WebCryptoErrorTypeNotSupported,
 129                 "Unsupported import key format for algorithm");
 130 }
 131
 132 Status Status::ErrorUnsupportedExportKeyFormat() {
 133   return Status(blink::WebCryptoErrorTypeNotSupported,
 134                 "Unsupported export key format for algorithm");
 135 }
 136
 137 Status Status::ErrorImportAesKeyLength() {
 138   return Status(blink::WebCryptoErrorTypeData,
 139                 "AES key data must be 128 or 256 bits");
 140 }
 141
 142 Status Status::ErrorGetAesKeyLength() {
 143   return Status(blink::WebCryptoErrorTypeOperation,
 144                 "AES key length must be 128 or 256 bits");
 145 }
 146
 147 Status Status::ErrorGenerateAesKeyLength() {
 148   return Status(blink::WebCryptoErrorTypeOperation,
 149                 "AES key length must be 128 or 256 bits");
 150 }
 151
 152 Status Status::ErrorAes192BitUnsupported() {
 153   return Status(blink::WebCryptoErrorTypeOperation,
 154                 "192-bit AES keys are not supported");
 155 }
 156
 157 Status Status::ErrorUnexpectedKeyType() {
 158   return Status(blink::WebCryptoErrorTypeInvalidAccess,
 159                 "The key is not of the expected type");
 160 }
 161
 162 Status Status::ErrorIncorrectSizeAesCbcIv() {
 163   return Status(blink::WebCryptoErrorTypeOperation,
 164                 "The \"iv\" has an unexpected length -- must be 16 bytes");
 165 }
 166
 167 Status Status::ErrorIncorrectSizeAesCtrCounter() {
 168   return Status(blink::WebCryptoErrorTypeOperation,
 169                 "The \"counter\" has an unexpected length -- must be 16 bytes");
 170 }
 171
 172 Status Status::ErrorInvalidAesCtrCounterLength() {
 173   return Status(blink::WebCryptoErrorTypeOperation,
 174                 "The \"length\" member must be >= 1 and <= 128");
 175 }
 176
 177 Status Status::ErrorAesCtrInputTooLongCounterRepeated() {
 178   return Status(blink::WebCryptoErrorTypeData,
 179                 "The input is too large for the counter length.");
 180 }
 181
 182 Status Status::ErrorDataTooLarge() {
 183   return Status(blink::WebCryptoErrorTypeOperation,
 184                 "The provided data is too large");
 185 }
 186
 187 Status Status::ErrorDataTooSmall() {
 188   return Status(blink::WebCryptoErrorTypeOperation,
 189                 "The provided data is too small");
 190 }
 191
 192 Status Status::ErrorUnsupported() {
 193   return ErrorUnsupported("The requested operation is unsupported");
 194 }
 195
 196 Status Status::ErrorUnsupported(const std::string& message) {
 197   return Status(blink::WebCryptoErrorTypeNotSupported, message);
 198 }
 199
 200 Status Status::ErrorUnexpected() {
 201   return Status(blink::WebCryptoErrorTypeOperation,
 202                 "Something unexpected happened...");
 203 }
 204
 205 Status Status::ErrorInvalidAesGcmTagLength() {
 206   return Status(
 207       blink::WebCryptoErrorTypeOperation,
 208       "The tag length is invalid: Must be 32, 64, 96, 104, 112, 120, or 128 "
 209       "bits");
 210 }
 211
 212 Status Status::ErrorInvalidAesKwDataLength() {
 213   return Status(blink::WebCryptoErrorTypeData,
 214                 "The AES-KW input data length is invalid: not a multiple of 8 "
 215                 "bytes");
 216 }
 217
 218 Status Status::ErrorGenerateKeyPublicExponent() {
 219   return Status(blink::WebCryptoErrorTypeOperation,
 220                 "The \"publicExponent\" must be either 3 or 65537");
 221 }
 222
 223 Status Status::ErrorImportRsaEmptyModulus() {
 224   return Status(blink::WebCryptoErrorTypeData, "The modulus is empty");
 225 }
 226
 227 Status Status::ErrorGenerateRsaUnsupportedModulus() {
 228   return Status(blink::WebCryptoErrorTypeOperation,
 229                 "The modulus length must be a multiple of 8 bits and >= 256 "
 230                 "and <= 16384");
 231 }
 232
 233 Status Status::ErrorImportRsaEmptyExponent() {
 234   return Status(blink::WebCryptoErrorTypeData,
 235                 "No bytes for the exponent were provided");
 236 }
 237
 238 Status Status::ErrorKeyNotExtractable() {
 239   return Status(blink::WebCryptoErrorTypeInvalidAccess,
 240                 "They key is not extractable");
 241 }
 242
 243 Status Status::ErrorGenerateHmacKeyLengthZero() {
 244   return Status(blink::WebCryptoErrorTypeOperation,
 245                 "HMAC key length must not be zero");
 246 }
 247
 248 Status Status::ErrorHmacImportEmptyKey() {
 249   return Status(blink::WebCryptoErrorTypeData,
 250                 "HMAC key data must not be empty");
 251 }
 252
 253 Status Status::ErrorGetHmacKeyLengthZero() {
 254   return Status(blink::WebCryptoErrorTypeType,
 255                 "HMAC key length must not be zero");
 256 }
 257
 258 Status Status::ErrorHmacImportBadLength() {
 259   return Status(
 260       blink::WebCryptoErrorTypeData,
 261       "The optional HMAC key length must be shorter than the key data, and by "
 262       "no more than 7 bits.");
 263 }
 264
 265 Status Status::ErrorCreateKeyBadUsages() {
 266   return Status(blink::WebCryptoErrorTypeSyntax,
 267                 "Cannot create a key using the specified key usages.");
 268 }
 269
 270 Status Status::ErrorCreateKeyEmptyUsages() {
 271   return Status(blink::WebCryptoErrorTypeSyntax,
 272                 "Usages cannot be empty when creating a key.");
 273 }
 274
 275 Status Status::ErrorImportedEcKeyIncorrectCurve() {
 276   return Status(
 277       blink::WebCryptoErrorTypeData,
 278       "The imported EC key specifies a different curve than requested");
 279 }
 280
 281 Status Status::ErrorJwkIncorrectCrv() {
 282   return Status(
 283       blink::WebCryptoErrorTypeData,
 284       "The JWK's \"crv\" member specifies a different curve than requested");
 285 }
 286
 287 Status Status::ErrorEcKeyInvalid() {
 288   return Status(blink::WebCryptoErrorTypeData,
 289                 "The imported EC key is invalid");
 290 }
 291
 292 Status Status::JwkOctetStringWrongLength(const std::string& member_name,
 293                                          size_t expected_length,
 294                                          size_t actual_length) {
 295   return Status(
 296       blink::WebCryptoErrorTypeData,
 297       base::StringPrintf(
 298           "The JWK's \"%s\" member defines an octet string of length %" PRIuS
 299           " bytes but should be %" PRIuS,
 300           member_name.c_str(), actual_length, expected_length));
 301 }
 302
 303 Status Status::ErrorEcdhPublicKeyWrongType() {
 304   return Status(
 305       blink::WebCryptoErrorTypeInvalidAccess,
 306       "The public parameter for ECDH key derivation is not a public EC key");
 307 }
 308
 309 Status Status::ErrorEcdhPublicKeyWrongAlgorithm() {
 310   return Status(
 311       blink::WebCryptoErrorTypeInvalidAccess,
 312       "The public parameter for ECDH key derivation must be for ECDH");
 313 }
 314
 315 Status Status::ErrorEcdhCurveMismatch() {
 316   return Status(blink::WebCryptoErrorTypeInvalidAccess,
 317                 "The public parameter for ECDH key derivation is for a "
 318                 "different named curve");
 319 }
 320
 321 Status Status::ErrorEcdhLengthTooBig(unsigned int max_length_bits) {
 322   return Status(blink::WebCryptoErrorTypeOperation,
 323                 base::StringPrintf(
 324                     "Length specified for ECDH key derivation is too large. "
 325                     "Maximum allowed is %u bits",
 326                     max_length_bits));
 327 }
 328
 329 Status Status::ErrorHkdfLengthTooLong() {
 330   return Status(blink::WebCryptoErrorTypeOperation,
 331                 "The length provided for HKDF is too large.");
 332 }
 333
 334 Status Status::ErrorHkdfDeriveBitsLengthNotSpecified() {
 335   // TODO(nharper): The spec might change so that an OperationError should be
 336   // thrown here instead of a TypeError.
 337   // (https://www.w3.org/Bugs/Public/show_bug.cgi?id=27771)
 338   return Status(blink::WebCryptoErrorTypeType,
 339                 "No length was specified for the HKDF Derive Bits operation.");
 340 }
 341
 342 Status Status::ErrorPbkdf2InvalidLength() {
 343   return Status(
 344       blink::WebCryptoErrorTypeOperation,
 345       "Length for PBKDF2 key derivation must be a multiple of 8 bits.");
 346 }
 347
 348 Status Status::ErrorPbkdf2DeriveBitsLengthNotSpecified() {
 349   return Status(
 350       blink::WebCryptoErrorTypeOperation,
 351       "No length was specified for the PBKDF2 Derive Bits operation.");
 352 }
 353
 354 Status::Status(blink::WebCryptoErrorType error_type,
 355                const std::string& error_details_utf8)
 356     : type_(TYPE_ERROR),
 357       error_type_(error_type),
 358       error_details_(error_details_utf8) {
 359 }
 360
 361 Status::Status(Type type) : type_(type) {
 362 }
 363
 364 }  // namespace webcrypto