1 // Copyright 2017 Google Inc. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 // 15 /////////////////////////////////////////////////////////////////////////////// 16 17 #include "tink/util/enums.h" 18 19 #include "absl/status/status.h" 20 #include "absl/strings/str_cat.h" 21 #include "tink/util/status.h" 22 #include "proto/common.pb.h" 23 #include "proto/ecdsa.pb.h" 24 #include "proto/tink.pb.h" 25 26 namespace crypto { 27 namespace tink { 28 namespace util { 29 30 namespace pb = google::crypto::tink; 31 32 // static SubtleToProto(subtle::EllipticCurveType type)33pb::EllipticCurveType Enums::SubtleToProto(subtle::EllipticCurveType type) { 34 switch (type) { 35 case subtle::EllipticCurveType::NIST_P256: 36 return pb::EllipticCurveType::NIST_P256; 37 case subtle::EllipticCurveType::NIST_P384: 38 return pb::EllipticCurveType::NIST_P384; 39 case subtle::EllipticCurveType::NIST_P521: 40 return pb::EllipticCurveType::NIST_P521; 41 case subtle::EllipticCurveType::CURVE25519: 42 return pb::EllipticCurveType::CURVE25519; 43 default: 44 return pb::EllipticCurveType::UNKNOWN_CURVE; 45 } 46 } 47 48 // static ProtoToSubtle(pb::EllipticCurveType type)49subtle::EllipticCurveType Enums::ProtoToSubtle(pb::EllipticCurveType type) { 50 switch (type) { 51 case pb::EllipticCurveType::NIST_P256: 52 return subtle::EllipticCurveType::NIST_P256; 53 case pb::EllipticCurveType::NIST_P384: 54 return subtle::EllipticCurveType::NIST_P384; 55 case pb::EllipticCurveType::NIST_P521: 56 return subtle::EllipticCurveType::NIST_P521; 57 case pb::EllipticCurveType::CURVE25519: 58 return subtle::EllipticCurveType::CURVE25519; 59 default: 60 return subtle::EllipticCurveType::UNKNOWN_CURVE; 61 } 62 } 63 64 // static SubtleToProto(subtle::EcPointFormat format)65pb::EcPointFormat Enums::SubtleToProto(subtle::EcPointFormat format) { 66 switch (format) { 67 case subtle::EcPointFormat::UNCOMPRESSED: 68 return pb::EcPointFormat::UNCOMPRESSED; 69 case subtle::EcPointFormat::DO_NOT_USE_CRUNCHY_UNCOMPRESSED: 70 return pb::EcPointFormat::DO_NOT_USE_CRUNCHY_UNCOMPRESSED; 71 case subtle::EcPointFormat::COMPRESSED: 72 return pb::EcPointFormat::COMPRESSED; 73 default: 74 return pb::EcPointFormat::UNKNOWN_FORMAT; 75 } 76 } 77 78 // static ProtoToSubtle(pb::EcPointFormat format)79subtle::EcPointFormat Enums::ProtoToSubtle(pb::EcPointFormat format) { 80 switch (format) { 81 case pb::EcPointFormat::UNCOMPRESSED: 82 return subtle::EcPointFormat::UNCOMPRESSED; 83 case pb::EcPointFormat::DO_NOT_USE_CRUNCHY_UNCOMPRESSED: 84 return subtle::EcPointFormat::DO_NOT_USE_CRUNCHY_UNCOMPRESSED; 85 case pb::EcPointFormat::COMPRESSED: 86 return subtle::EcPointFormat::COMPRESSED; 87 default: 88 return subtle::EcPointFormat::UNKNOWN_FORMAT; 89 } 90 } 91 92 // static SubtleToProto(subtle::HashType type)93pb::HashType Enums::SubtleToProto(subtle::HashType type) { 94 switch (type) { 95 case subtle::HashType::SHA1: 96 return pb::HashType::SHA1; 97 case subtle::HashType::SHA224: 98 return pb::HashType::SHA224; 99 case subtle::HashType::SHA256: 100 return pb::HashType::SHA256; 101 case subtle::HashType::SHA384: 102 return pb::HashType::SHA384; 103 case subtle::HashType::SHA512: 104 return pb::HashType::SHA512; 105 default: 106 return pb::HashType::UNKNOWN_HASH; 107 } 108 } 109 110 // static ProtoToSubtle(pb::HashType type)111subtle::HashType Enums::ProtoToSubtle(pb::HashType type) { 112 switch (type) { 113 case pb::HashType::SHA1: 114 return subtle::HashType::SHA1; 115 case pb::HashType::SHA224: 116 return subtle::HashType::SHA224; 117 case pb::HashType::SHA256: 118 return subtle::HashType::SHA256; 119 case pb::HashType::SHA384: 120 return subtle::HashType::SHA384; 121 case pb::HashType::SHA512: 122 return subtle::HashType::SHA512; 123 default: 124 return subtle::HashType::UNKNOWN_HASH; 125 } 126 } 127 128 // static ProtoToSubtle(pb::EcdsaSignatureEncoding encoding)129subtle::EcdsaSignatureEncoding Enums::ProtoToSubtle( 130 pb::EcdsaSignatureEncoding encoding) { 131 switch (encoding) { 132 case pb::EcdsaSignatureEncoding::DER: 133 return subtle::EcdsaSignatureEncoding::DER; 134 case pb::EcdsaSignatureEncoding::IEEE_P1363: 135 return subtle::EcdsaSignatureEncoding::IEEE_P1363; 136 default: 137 return subtle::EcdsaSignatureEncoding::UNKNOWN_ENCODING; 138 } 139 } 140 141 // static SubtleToProto(subtle::EcdsaSignatureEncoding encoding)142pb::EcdsaSignatureEncoding Enums::SubtleToProto( 143 subtle::EcdsaSignatureEncoding encoding) { 144 switch (encoding) { 145 case subtle::EcdsaSignatureEncoding::DER: 146 return pb::EcdsaSignatureEncoding::DER; 147 case subtle::EcdsaSignatureEncoding::IEEE_P1363: 148 return pb::EcdsaSignatureEncoding::IEEE_P1363; 149 default: 150 return pb::EcdsaSignatureEncoding::UNKNOWN_ENCODING; 151 } 152 } 153 154 // static KeyStatusName(pb::KeyStatusType key_status_type)155const char* Enums::KeyStatusName(pb::KeyStatusType key_status_type) { 156 switch (key_status_type) { 157 case pb::KeyStatusType::ENABLED: 158 return "ENABLED"; 159 case pb::KeyStatusType::DISABLED: 160 return "DISABLED"; 161 case pb::KeyStatusType::DESTROYED: 162 return "DESTROYED"; 163 default: 164 return "UNKNOWN_STATUS"; 165 } 166 } 167 168 // static HashName(pb::HashType hash_type)169const char* Enums::HashName(pb::HashType hash_type) { 170 switch (hash_type) { 171 case pb::HashType::SHA1: 172 return "SHA1"; 173 case pb::HashType::SHA224: 174 return "SHA224"; 175 case pb::HashType::SHA256: 176 return "SHA256"; 177 case pb::HashType::SHA384: 178 return "SHA384"; 179 case pb::HashType::SHA512: 180 return "SHA512"; 181 default: 182 return "UNKNOWN_HASH"; 183 } 184 } 185 186 // static HashLength(pb::HashType hash_type)187util::StatusOr<int> Enums::HashLength(pb::HashType hash_type) { 188 switch (hash_type) { 189 case pb::HashType::SHA224: 190 return 28; 191 case pb::HashType::SHA256: 192 return 32; 193 case pb::HashType::SHA384: 194 return 48; 195 case pb::HashType::SHA512: 196 return 64; 197 default: 198 return util::Status(absl::StatusCode::kInvalidArgument, 199 absl::StrCat("Unsupported hashing algorithm ", 200 util::Enums::HashName(hash_type))); 201 } 202 } 203 204 // static KeyMaterialName(pb::KeyData::KeyMaterialType key_material_type)205const char* Enums::KeyMaterialName( 206 pb::KeyData::KeyMaterialType key_material_type) { 207 switch (key_material_type) { 208 case pb::KeyData::SYMMETRIC: 209 return "SYMMETRIC"; 210 case pb::KeyData::ASYMMETRIC_PRIVATE: 211 return "ASYMMETRIC_PRIVATE"; 212 case pb::KeyData::ASYMMETRIC_PUBLIC: 213 return "ASYMMETRIC_PUBLIC"; 214 case pb::KeyData::REMOTE: 215 return "REMOTE"; 216 default: 217 return "UNKNOWN_KEYMATERIAL"; 218 } 219 } 220 221 // static OutputPrefixName(pb::OutputPrefixType output_prefix_type)222const char* Enums::OutputPrefixName(pb::OutputPrefixType output_prefix_type) { 223 switch (output_prefix_type) { 224 case pb::OutputPrefixType::TINK: 225 return "TINK"; 226 case pb::OutputPrefixType::LEGACY: 227 return "LEGACY"; 228 case pb::OutputPrefixType::RAW: 229 return "RAW"; 230 case pb::OutputPrefixType::CRUNCHY: 231 return "CRUNCHY"; 232 default: 233 return "UNKNOWN_PREFIX"; 234 } 235 } 236 237 // static KeyStatus(absl::string_view name)238pb::KeyStatusType Enums::KeyStatus(absl::string_view name) { 239 if (name == "ENABLED") return pb::KeyStatusType::ENABLED; 240 if (name == "DISABLED") return pb::KeyStatusType::DISABLED; 241 if (name == "DESTROYED") return pb::KeyStatusType::DESTROYED; 242 return pb::KeyStatusType::UNKNOWN_STATUS; 243 } 244 245 // static Hash(absl::string_view name)246pb::HashType Enums::Hash(absl::string_view name) { 247 if (name == "SHA1") return pb::HashType::SHA1; 248 if (name == "SHA224") return pb::HashType::SHA224; 249 if (name == "SHA256") return pb::HashType::SHA256; 250 if (name == "SHA384") return pb::HashType::SHA384; 251 if (name == "SHA512") return pb::HashType::SHA512; 252 return pb::HashType::UNKNOWN_HASH; 253 } 254 255 // static KeyMaterial(absl::string_view name)256pb::KeyData::KeyMaterialType Enums::KeyMaterial(absl::string_view name) { 257 if (name == "SYMMETRIC") return pb::KeyData::SYMMETRIC; 258 if (name == "ASYMMETRIC_PRIVATE") return pb::KeyData::ASYMMETRIC_PRIVATE; 259 if (name == "ASYMMETRIC_PUBLIC") return pb::KeyData::ASYMMETRIC_PUBLIC; 260 if (name == "REMOTE") return pb::KeyData::REMOTE; 261 return pb::KeyData::UNKNOWN_KEYMATERIAL; 262 } 263 264 // static OutputPrefix(absl::string_view name)265pb::OutputPrefixType Enums::OutputPrefix(absl::string_view name) { 266 if (name == "TINK") return pb::OutputPrefixType::TINK; 267 if (name == "LEGACY") return pb::OutputPrefixType::LEGACY; 268 if (name == "RAW") return pb::OutputPrefixType::RAW; 269 if (name == "CRUNCHY") return pb::OutputPrefixType::CRUNCHY; 270 return pb::OutputPrefixType::UNKNOWN_PREFIX; 271 } 272 273 } // namespace util 274 } // namespace tink 275 } // namespace crypto 276