Esempio n. 1
0
        public void DecryptThenVerifyByListOfTrustedCard_EncryptedMessage_ShouldGivenMessageBeDecryptedAndVerified()
        {
            // Create Alice's key
            var AppAccessToken = ConfigurationManager.AppSettings["virgil:AppAccessToken"];
            var virgil         = new VirgilApi(AppAccessToken);
            var aliceKey       = virgil.Keys.Generate();
            var aliceCard      = virgil.Cards.Create("AliceCard", aliceKey);
            var bobKey         = virgil.Keys.Generate();
            var bobCard        = virgil.Cards.Create("BobCard", bobKey);
            var samCard        = virgil.Cards.Create("SamCard", virgil.Keys.Generate());

            // Alice signs some message then ecrypt it for Bob and Sam
            var message = "Encrypt me, please!";
            var signedAndEncryptedMessage = aliceKey.SignThenEncrypt(VirgilBuffer.From(message),
                                                                     new List <VirgilCard>()
            {
                bobCard, samCard
            });

            // Somehow transfer signed and encrypted message as Base64 string
            var transferMessage = signedAndEncryptedMessage.ToString(StringEncoding.Base64);

            // Bob tries to decrypt and verify message
            var receivedMessage             = VirgilBuffer.From(transferMessage, StringEncoding.Base64);
            var decryptedAneVerifiedMessage = bobKey.DecryptThenVerify(receivedMessage, samCard, aliceCard);

            decryptedAneVerifiedMessage.ToString().ShouldBeEquivalentTo(message);
        }
        public void RevokeWithEmptyAppCredentials_PredefinedCard_ShouldOccurAppCredentialsException()
        {
            var AppAccessToken = ConfigurationManager.AppSettings["virgil:AppAccessToken"];
            var virgil         = new VirgilApi(AppAccessToken);
            var aliceKey       = virgil.Keys.Generate();
            var aliceCard      = virgil.Cards.Create("AliceCard", aliceKey);

            Assert.ThrowsAsync <Exceptions.AppCredentialsException>(() => virgil.Cards.RevokeAsync(aliceCard));
        }
Esempio n. 3
0
        public void Verify_GivenMessageAndSignature_ShouldSignedDataBeVerified()
        {
            // Create Alice's key
            var AppAccessToken = ConfigurationManager.AppSettings["virgil:AppAccessToken"];
            var virgil         = new VirgilApi(AppAccessToken);
            var aliceKey       = virgil.Keys.Generate();
            var aliceCard      = virgil.Cards.Create("AliceCard", aliceKey);

            // Sign some message
            var message   = "Encrypt me, please!";
            var signature = aliceKey.Sign(VirgilBuffer.From(message));

            // Somehow transfer signature as Base64 string
            var transferSignatureData = signature.ToString(StringEncoding.Base64);

            // Verify message by Alice's Card using received signature
            var receivedSignature = VirgilBuffer.From(transferSignatureData, StringEncoding.Base64);
            var isVerified        = aliceCard.Verify(message, receivedSignature);

            isVerified.ShouldBeEquivalentTo(true);
        }
Esempio n. 4
0
        public void Decrypt_PredefinedCipherDataGiven_ShouldCipherDataBeDecrypted()
        {
            // Create Alice's card
            var AppAccessToken = ConfigurationManager.AppSettings["virgil:AppAccessToken"];
            var virgil         = new VirgilApi(AppAccessToken);
            var aliceKey       = virgil.Keys.Generate();
            var aliceCard      = virgil.Cards.Create("AliceCard", aliceKey);

            // Encrypt some message
            var message    = "Encrypt me, please!";
            var cipherData = aliceCard.Encrypt(VirgilBuffer.From(message));

            // Somehow transfer encrypted message as Base64 string
            var transferData = cipherData.ToString(StringEncoding.Base64);

            // Decrypt received message
            var receivedCipherData = VirgilBuffer.From(transferData, StringEncoding.Base64);
            var decryptedMessage   = aliceKey.Decrypt(receivedCipherData);

            message.ShouldBeEquivalentTo(decryptedMessage.ToString());
        }
        public async Task PublishCardWithAppCredentials_PredefinedCard_ShouldPublishCard()
        {
            var clientParams = new VirgilClientParams(ConfigurationManager.AppSettings["virgil:AppAccessToken"]);

            clientParams.SetCardsServiceAddress(ConfigurationManager.AppSettings["virgil:CardsServicesAddress"]);
            clientParams.SetIdentityServiceAddress(ConfigurationManager.AppSettings["virgil:IdentityServiceAddress"]);
            clientParams.SetRAServiceAddress(ConfigurationManager.AppSettings["virgil:RAServicesAddress"]);
            clientParams.SetReadCardsServiceAddress(ConfigurationManager.AppSettings["virgil:CardsReadServicesAddress"]);

            // To use staging Verifier instead of default verifier
            var cardVerifier = new CardVerifierInfo
            {
                CardId        = ConfigurationManager.AppSettings["virgil:ServiceCardId"],
                PublicKeyData = VirgilBuffer.From(ConfigurationManager.AppSettings["virgil:ServicePublicKeyDerBase64"],
                                                  StringEncoding.Base64)
            };
            var virgil = new VirgilApi(new VirgilApiContext
            {
                Credentials = new AppCredentials
                {
                    AppId          = ConfigurationManager.AppSettings["virgil:AppID"],
                    AppKey         = VirgilBuffer.FromFile(ConfigurationManager.AppSettings["virgil:AppKeyPath"]),
                    AppKeyPassword = ConfigurationManager.AppSettings["virgil:AppKeyPassword"]
                },
                ClientParams        = clientParams,
                UseBuiltInVerifiers = false,
                CardVerifiers       = new[] { cardVerifier }
            });

            var aliceKey  = virgil.Keys.Generate();
            var aliceCard = virgil.Cards.Create("AliceCard", aliceKey);

            await virgil.Cards.PublishAsync(aliceCard);

            aliceCard.Id.Should().NotBeEmpty();

            Assert.IsTrue(aliceCard.IsPairFor(aliceKey));
            await virgil.Cards.RevokeAsync(aliceCard);
        }