1 /* 2 * Copyright 2011, Axel Dörfler, axeld@pinc-software.de. 3 * Distributed under the terms of the MIT License. 4 */ 5 6 7 #include <Key.h> 8 9 #include <stdio.h> 10 11 12 #if 0 13 // TODO: move this to the KeyStore or the registrar backend if needed 14 static bool 15 CompareLists(BObjectList<BString> a, BObjectList<BString> b) 16 { 17 if (a.CountItems() != b.CountItems()) 18 return false; 19 20 for (int32 i = 0; i < a.CountItems(); i++) { 21 if (*a.ItemAt(i) != *b.ItemAt(i)) 22 return false; 23 } 24 25 return true; 26 } 27 #endif 28 29 30 // #pragma mark - Generic BKey 31 32 33 BKey::BKey() 34 { 35 Unset(); 36 } 37 38 39 BKey::BKey(BKeyPurpose purpose, const char* identifier, 40 const char* secondaryIdentifier, const uint8* data, size_t length) 41 { 42 SetTo(purpose, identifier, secondaryIdentifier, data, length); 43 } 44 45 46 BKey::BKey(BKey& other) 47 { 48 *this = other; 49 } 50 51 52 BKey::~BKey() 53 { 54 } 55 56 57 void 58 BKey::Unset() 59 { 60 SetTo(B_KEY_PURPOSE_GENERIC, "", "", NULL, 0); 61 } 62 63 64 status_t 65 BKey::SetTo(BKeyPurpose purpose, const char* identifier, 66 const char* secondaryIdentifier, const uint8* data, size_t length) 67 { 68 fCreationTime = 0; 69 SetPurpose(purpose); 70 SetIdentifier(identifier); 71 SetSecondaryIdentifier(secondaryIdentifier); 72 return SetData(data, length); 73 } 74 75 76 void 77 BKey::SetPurpose(BKeyPurpose purpose) 78 { 79 fPurpose = purpose; 80 } 81 82 83 BKeyPurpose 84 BKey::Purpose() const 85 { 86 return fPurpose; 87 } 88 89 90 void 91 BKey::SetIdentifier(const char* identifier) 92 { 93 fIdentifier = identifier; 94 } 95 96 97 const char* 98 BKey::Identifier() const 99 { 100 return fIdentifier.String(); 101 } 102 103 104 void 105 BKey::SetSecondaryIdentifier(const char* identifier) 106 { 107 fSecondaryIdentifier = identifier; 108 } 109 110 111 const char* 112 BKey::SecondaryIdentifier() const 113 { 114 return fSecondaryIdentifier.String(); 115 } 116 117 118 status_t 119 BKey::SetData(const uint8* data, size_t length) 120 { 121 fData.SetSize(0); 122 ssize_t bytesWritten = fData.WriteAt(0, data, length); 123 if (bytesWritten < 0) 124 return (status_t)bytesWritten; 125 126 return (size_t)bytesWritten == length ? B_OK : B_NO_MEMORY; 127 } 128 129 130 size_t 131 BKey::DataLength() const 132 { 133 return fData.BufferLength(); 134 } 135 136 137 const uint8* 138 BKey::Data() const 139 { 140 return (const uint8*)fData.Buffer(); 141 } 142 143 144 status_t 145 BKey::GetData(uint8* buffer, size_t bufferSize) const 146 { 147 ssize_t bytesRead = fData.ReadAt(0, buffer, bufferSize); 148 if (bytesRead < 0) 149 return (status_t)bytesRead; 150 151 return B_OK; 152 } 153 154 155 156 const char* 157 BKey::Owner() const 158 { 159 return fOwner.String(); 160 } 161 162 163 bigtime_t 164 BKey::CreationTime() const 165 { 166 return fCreationTime; 167 } 168 169 170 status_t 171 BKey::Flatten(BMessage& message) const 172 { 173 if (message.MakeEmpty() != B_OK 174 || message.AddUInt32("type", Type()) != B_OK 175 || message.AddUInt32("purpose", fPurpose) != B_OK 176 || message.AddString("identifier", fIdentifier) != B_OK 177 || message.AddString("secondaryIdentifier", fSecondaryIdentifier) 178 != B_OK 179 || message.AddString("owner", fOwner) != B_OK 180 || message.AddInt64("creationTime", fCreationTime) != B_OK 181 || message.AddData("data", B_RAW_TYPE, fData.Buffer(), 182 fData.BufferLength()) != B_OK) { 183 return B_ERROR; 184 } 185 186 return B_OK; 187 } 188 189 190 status_t 191 BKey::Unflatten(const BMessage& message) 192 { 193 BKeyType type; 194 if (message.FindUInt32("type", (uint32*)&type) != B_OK || type != Type()) 195 return B_BAD_VALUE; 196 197 const void* data = NULL; 198 ssize_t dataLength = 0; 199 if (message.FindUInt32("purpose", (uint32*)&fPurpose) != B_OK 200 || message.FindString("identifier", &fIdentifier) != B_OK 201 || message.FindString("secondaryIdentifier", &fSecondaryIdentifier) 202 != B_OK 203 || message.FindString("owner", &fOwner) != B_OK 204 || message.FindInt64("creationTime", &fCreationTime) != B_OK 205 || message.FindData("data", B_RAW_TYPE, &data, &dataLength) != B_OK 206 || dataLength < 0) { 207 return B_ERROR; 208 } 209 210 return SetData((const uint8*)data, (size_t)dataLength); 211 } 212 213 214 BKey& 215 BKey::operator=(const BKey& other) 216 { 217 SetPurpose(other.Purpose()); 218 SetData((const uint8*)other.Data(), other.DataLength()); 219 220 fIdentifier = other.fIdentifier; 221 fSecondaryIdentifier = other.fSecondaryIdentifier; 222 fOwner = other.fOwner; 223 fCreationTime = other.fCreationTime; 224 225 return *this; 226 } 227 228 229 bool 230 BKey::operator==(const BKey& other) const 231 { 232 return Type() == other.Type() 233 && DataLength() == other.DataLength() 234 && Purpose() == other.Purpose() 235 && fOwner == other.fOwner 236 && fIdentifier == other.fIdentifier 237 && fSecondaryIdentifier == other.fSecondaryIdentifier 238 && memcmp(Data(), other.Data(), DataLength()) == 0; 239 } 240 241 242 bool 243 BKey::operator!=(const BKey& other) const 244 { 245 return !(*this == other); 246 } 247 248 249 void 250 BKey::PrintToStream() 251 { 252 if (Type() == B_KEY_TYPE_GENERIC) 253 printf("generic key:\n"); 254 255 const char* purposeString = "unknown"; 256 switch (fPurpose) { 257 case B_KEY_PURPOSE_ANY: 258 purposeString = "any"; 259 break; 260 case B_KEY_PURPOSE_GENERIC: 261 purposeString = "generic"; 262 break; 263 case B_KEY_PURPOSE_KEYRING: 264 purposeString = "keyring"; 265 break; 266 case B_KEY_PURPOSE_WEB: 267 purposeString = "web"; 268 break; 269 case B_KEY_PURPOSE_NETWORK: 270 purposeString = "network"; 271 break; 272 case B_KEY_PURPOSE_VOLUME: 273 purposeString = "volume"; 274 break; 275 } 276 277 printf("\tpurpose: %s\n", purposeString); 278 printf("\tidentifier: \"%s\"\n", fIdentifier.String()); 279 printf("\tsecondary identifier: \"%s\"\n", fSecondaryIdentifier.String()); 280 printf("\towner: \"%s\"\n", fOwner.String()); 281 printf("\tcreation time: %" B_PRIu64 "\n", fCreationTime); 282 printf("\traw data length: %" B_PRIuSIZE "\n", fData.BufferLength()); 283 } 284 285 286 // #pragma mark - BPasswordKey 287 288 289 BPasswordKey::BPasswordKey() 290 { 291 } 292 293 294 BPasswordKey::BPasswordKey(const char* password, BKeyPurpose purpose, 295 const char* identifier, const char* secondaryIdentifier) 296 : 297 BKey(purpose, identifier, secondaryIdentifier, (const uint8*)password, 298 strlen(password) + 1) 299 { 300 } 301 302 303 BPasswordKey::BPasswordKey(BPasswordKey& other) 304 { 305 } 306 307 308 BPasswordKey::~BPasswordKey() 309 { 310 } 311 312 313 status_t 314 BPasswordKey::SetTo(const char* password, BKeyPurpose purpose, 315 const char* identifier, const char* secondaryIdentifier) 316 { 317 return BKey::SetTo(purpose, identifier, secondaryIdentifier, 318 (const uint8*)password, strlen(password) + 1); 319 } 320 321 322 status_t 323 BPasswordKey::SetPassword(const char* password) 324 { 325 return SetData((const uint8*)password, strlen(password) + 1); 326 } 327 328 329 const char* 330 BPasswordKey::Password() const 331 { 332 return (const char*)Data(); 333 } 334 335 336 void 337 BPasswordKey::PrintToStream() 338 { 339 printf("password key:\n"); 340 BKey::PrintToStream(); 341 printf("\tpassword: \"%s\"\n", Password()); 342 } 343