public override int GetHashCode() { unchecked { var hashCode = (UserPublicKey != null ? UserPublicKey.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (KeyHandle != null ? KeyHandle.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (AttestationCertificate != null ? AttestationCertificate.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (Signature != null ? Signature.GetHashCode() : 0); return(hashCode); } }
public V2AsymmetricKeyWrapHeaderBlock(UserPublicKey publicKey, SymmetricKey masterKey, SymmetricIV masterIV) : this(Resolve.RandomGenerator.Generate(DATABLOCK_LENGTH)) { if (publicKey == null) { throw new ArgumentNullException("publicKey"); } byte[] encrypted = publicKey.PublicKey.Transform(masterKey + masterIV); GetDataBlockBytesReference().SetFrom(encrypted); }
public void TestOnePublicKey() { IAsymmetricPublicKey key = New <IAsymmetricFactory>().CreatePublicKey(Resources.PublicKey1); UserPublicKey userPublicKey = new UserPublicKey(EmailAddress.Parse("*****@*****.**"), key); UserPublicKeyUpdateStatus updateStatus = new UserPublicKeyUpdateStatus(); Assert.That(updateStatus.Status(userPublicKey), Is.EqualTo(PublicKeyUpdateStatus.NotRecentlyUpdated)); updateStatus.SetStatus(userPublicKey, PublicKeyUpdateStatus.RecentlyUpdated); Assert.That(updateStatus.Status(userPublicKey), Is.EqualTo(PublicKeyUpdateStatus.RecentlyUpdated)); updateStatus.Clear(); Assert.That(updateStatus.Status(userPublicKey), Is.EqualTo(PublicKeyUpdateStatus.NotRecentlyUpdated)); }
public Task AddAsync(IEnumerable <UserPublicKey> publicKeys) { foreach (UserPublicKey userPublicKey in publicKeys) { UserPublicKey existingKey = _publicKeys.FirstOrDefault(pk => pk.Email == userPublicKey.Email); if (existingKey != null) { _publicKeys.Remove(existingKey); } _publicKeys.Add(userPublicKey); } return(Constant.CompletedTask); }
public PublicKeyUpdateStatus Status(UserPublicKey userPublicKey) { if (userPublicKey == null) { throw new ArgumentNullException(nameof(userPublicKey)); } PublicKeyUpdateStatus value; if (_publicKeyUpdateStatus.TryGetValue(userPublicKey.PublicKey.Thumbprint, out value)) { return(value); } return(PublicKeyUpdateStatus.NotRecentlyUpdated); }
/// <summary> /// Checks the public key of a user. /// </summary> /// <param name="publicKey">The public key to check.</param> /// <exception cref="Dracoon.Crypto.Sdk.InvalidKeyPairException"/> private static void ValidateUserPublicKey(UserPublicKey publicKey) { if (publicKey == null) { throw new InvalidKeyPairException("Public key container cannot be null."); } if (publicKey.Version == null || !publicKey.Version.Equals(CryptoConstants.defaultVersion)) { throw new InvalidKeyPairException("Unknown public key version."); } if (publicKey.PublicKey == null | publicKey.PublicKey.Length == 0) { throw new InvalidKeyPairException("Public key cannot be null or empty."); } }
public async Task TestInitialOneKeyState() { IAsymmetricPublicKey key = New <IAsymmetricFactory>().CreatePublicKey(Resources.PublicKey1); UserPublicKey userPublicKey = new UserPublicKey(EmailAddress.Parse("*****@*****.**"), key); using (KnownPublicKeys knownPublicKeys = New <KnownPublicKeys>()) { knownPublicKeys.AddOrReplace(userPublicKey); } SharingListViewModel model = await SharingListViewModel.CreateForFilesAsync(new string[0], LogOnIdentity.Empty); Assert.That(model.SharedWith.Any(), Is.False, "There are no known public keys, and none are set as shared."); Assert.That(model.NotSharedWith.Count(), Is.EqualTo(1), "There is one known public key, so this should be available as unshared."); }
public async Task <UserPublicKey> OtherPublicKeyAsync(EmailAddress email) { if (Identity.UserEmail == EmailAddress.Empty) { throw new InvalidOperationException("The account service requires a user."); } return(await Task.Run(() => { using (KnownPublicKeys knowPublicKeys = New <KnownPublicKeys>()) { UserPublicKey publicKey = knowPublicKeys.PublicKeys.Where(pk => pk.Email == email).FirstOrDefault(); return publicKey; } }).Free()); }
public static async Task <IEnumerable <UserPublicKey> > ToAvailableKnownPublicKeysAsync(this IEnumerable <EmailAddress> emails, LogOnIdentity identity) { List <UserPublicKey> availablePublicKeys = new List <UserPublicKey>(); using (KnownPublicKeys knownPublicKeys = New <KnownPublicKeys>()) { foreach (EmailAddress email in emails) { UserPublicKey key = await knownPublicKeys.GetAsync(email, identity); if (key != null) { availablePublicKeys.Add(key); } } } return(availablePublicKeys); }
public static async Task <UserPublicKey> GetAsync(this KnownPublicKeys knownPublicKeys, EmailAddress email, LogOnIdentity identity) { UserPublicKey key = knownPublicKeys.PublicKeys.FirstOrDefault(upk => upk.Email == email); if (key != null && New <UserPublicKeyUpdateStatus>().Status(key) == PublicKeyUpdateStatus.RecentlyUpdated) { return(key); } if (New <AxCryptOnlineState>().IsOffline) { return(key); } if (identity == LogOnIdentity.Empty || identity.UserEmail == EmailAddress.Empty) { return(key); } IAccountService accountService = New <LogOnIdentity, IAccountService>(identity); if (await accountService.IsAccountSourceLocalAsync()) { return(key); } if (!New <LicensePolicy>().Capabilities.Has(LicenseCapability.KeySharing) && email != _licenseAuthorityEmail) { return(key); } AccountStorage accountStorage = new AccountStorage(New <LogOnIdentity, IAccountService>(identity)); CustomMessageParameters invitationMessageParameters = new CustomMessageParameters(new CultureInfo(New <UserSettings>().MessageCulture), New <UserSettings>().CustomInvitationMessage); UserPublicKey userPublicKey = await accountStorage.GetOtherUserInvitePublicKeyAsync(email, invitationMessageParameters).Free(); if (userPublicKey != null) { knownPublicKeys.AddOrReplace(userPublicKey); New <UserPublicKeyUpdateStatus>().SetStatus(userPublicKey, PublicKeyUpdateStatus.RecentlyUpdated); } return(userPublicKey); }
public static async Task <IEnumerable <UserPublicKey> > GetKnownPublicKeysAsync(this IEnumerable <UserPublicKey> publicKeys, LogOnIdentity identity) { List <UserPublicKey> knownKeys = new List <UserPublicKey>(); using (KnownPublicKeys knownPublicKeys = New <KnownPublicKeys>()) { foreach (UserPublicKey publicKey in publicKeys) { UserPublicKey key = await knownPublicKeys.GetAsync(publicKey.Email, identity); if (key == null) { knownKeys.Add(publicKey); continue; } knownKeys.Add(key); } } return(knownKeys); }
public void TestCreateSingleKey() { FakeInMemoryDataStoreItem store = new FakeInMemoryDataStoreItem("KnownPublicKeys.txt"); IAsymmetricPublicKey key = New <IAsymmetricFactory>().CreatePublicKey(Resources.PublicKey1); UserPublicKey userPublicKey = new UserPublicKey(EmailAddress.Parse("*****@*****.**"), key); using (KnownPublicKeys knownPublicKeys = KnownPublicKeys.Load(store, Resolve.Serializer)) { Assert.That(knownPublicKeys.PublicKeys.Count(), Is.EqualTo(0), "There should be no entries now."); knownPublicKeys.AddOrReplace(userPublicKey); Assert.That(knownPublicKeys.PublicKeys.Count(), Is.EqualTo(1), "There should be one entry now."); } using (KnownPublicKeys knownPublicKeys = KnownPublicKeys.Load(store, Resolve.Serializer)) { Assert.That(knownPublicKeys.PublicKeys.Count(), Is.EqualTo(1), "There should be one entry now."); Assert.That(knownPublicKeys.PublicKeys.First(), Is.EqualTo(userPublicKey), "The instances should compare equal"); } }
/// <summary> /// Import a public key manually by the user. The key is also marked as imported by the user. /// </summary> /// <param name="publicKeyStore"></param> /// <returns>true if the import was successful</returns> public bool UserImport(IDataStore publicKeyStore) { UserPublicKey publicKey = null; try { publicKey = _serializer.Deserialize <UserPublicKey>(publicKeyStore); } catch (JsonException jex) { New <IReport>().Exception(jex); } if (publicKey == null) { return(false); } publicKey.IsUserImported = true; AddOrReplace(publicKey); return(true); }
public void AddOrReplace(UserPublicKey publicKey) { if (publicKey == null) { throw new ArgumentNullException("publicKey"); } for (int i = 0; i < _publicKeys.Count; ++i) { if (_publicKeys[i] == publicKey) { return; } if (_publicKeys[i].Email == publicKey.Email) { _dirty = true; _publicKeys[i] = publicKey; return; } } _dirty = true; _publicKeys.Add(publicKey); }
public void ToStream(Stream stream) { if (stream == null) { throw new ArgumentNullException("stream"); } using (var binaryWriter = new BinaryWriter(stream)) { binaryWriter.Write(RegistrationReservedByte); var publicKey = UserPublicKey.ToByteArray(); binaryWriter.Write(publicKey); var keyHandle = KeyHandle.ToByteArray(); binaryWriter.Write((byte)keyHandle.Length); binaryWriter.Write(keyHandle); var certBytes = AttestationCertificate.Certificate.GetEncoded(); binaryWriter.Write(certBytes); binaryWriter.Write(Signature.ToByteArray()); } }
public void TestGenerateUserKeyPair_Success() { UserKeyPair testUkp = Crypto.GenerateUserKeyPair("A", "Qwer1234"); Assert.IsNotNull(testUkp, "Key pair is null!"); UserPrivateKey testPrivateKey = testUkp.UserPrivateKey; Assert.IsNotNull(testPrivateKey, "Private key container is null!"); Assert.IsNotNull(testPrivateKey.Version, "Private key version is null"); Assert.IsTrue(testPrivateKey.Version.Length > 0, "Private key version is empty!"); Assert.IsTrue(testPrivateKey.Version.Equals("A"), "Private key version is invalid!"); Assert.IsNotNull(testPrivateKey.PrivateKey, "Private key is null!"); Assert.IsTrue(testPrivateKey.PrivateKey.StartsWith("-----BEGIN ENCRYPTED PRIVATE KEY-----"), "Privat ekey is invalid!"); UserPublicKey testPublicKey = testUkp.UserPublicKey; Assert.IsNotNull(testPublicKey, "Public key container is null!"); Assert.IsNotNull(testPublicKey.Version, "Public key version is null"); Assert.IsTrue(testPublicKey.Version.Length > 0, "Public key version is empty!"); Assert.IsTrue(testPublicKey.Version.Equals("A"), "Public key version is invalid!"); Assert.IsNotNull(testPublicKey.PublicKey, "Public key is null!"); Assert.IsTrue(testPublicKey.PublicKey.StartsWith("-----BEGIN PUBLIC KEY-----"), "Public ekey is invalid!"); }
public async Task TestMoveTwoFromUnsharedToShared() { IAsymmetricPublicKey key1 = New <IAsymmetricFactory>().CreatePublicKey(Resources.PublicKey1); UserPublicKey userPublicKey1 = new UserPublicKey(EmailAddress.Parse("*****@*****.**"), key1); IAsymmetricPublicKey key2 = New <IAsymmetricFactory>().CreatePublicKey(Resources.PublicKey2); UserPublicKey userPublicKey2 = new UserPublicKey(EmailAddress.Parse("*****@*****.**"), key2); using (KnownPublicKeys knownPublicKeys = New <KnownPublicKeys>()) { knownPublicKeys.AddOrReplace(userPublicKey1); knownPublicKeys.AddOrReplace(userPublicKey2); } SharingListViewModel model = await SharingListViewModel.CreateForFilesAsync(new string[0], LogOnIdentity.Empty); Assert.That(model.SharedWith.Any(), Is.False, "There are no known public keys, and none are set as shared."); Assert.That(model.NotSharedWith.Count(), Is.EqualTo(2), "There are two known public keys, so they should be available as unshared."); await model.AddKeyShares.ExecuteAsync(new[] { userPublicKey2.Email, userPublicKey1.Email, }); Assert.That(model.SharedWith.Count(), Is.EqualTo(2), "Two were set as shared, so there should be two here now."); Assert.That(model.NotSharedWith.Count(), Is.EqualTo(0), "Both unshared were set as shared, so there should be none here now."); }
public EncFileUpload(IInternalDracoonClient client, string actionId, FileUploadRequest request, Stream input, UserPublicKey publicKey, long fileSize) : base(client, actionId, request, input, fileSize) { _userPublicKey = publicKey; LogTag = nameof(EncFileUpload); }
public V1AxCryptDocument() { CryptoFactory = new V1Aes128CryptoFactory(); AsymmetricRecipients = new UserPublicKey[0]; }
protected bool Equals(KeyRegisterResponse other) { return(UserPublicKey.SequenceEqual(other.UserPublicKey) && KeyHandle.SequenceEqual(other.KeyHandle) && Equals(AttestationCertificate, other.AttestationCertificate) && Signature.SequenceEqual(other.Signature)); }