/// <summary>
/// Loads <see cref="RawSignedModel"/> from the specified <see cref="Card"/>.
/// </summary>
/// <param name="cardCrypto">an instance of <see cref="ICardCrypto"/>.</param>
/// <param name="card">an instance of <see cref="Card"/> to get
/// <see cref="RawSignedModel"/> from.</param>
/// <returns>Loaded instance of <see cref="RawSignedModel"/>.</returns>
public static RawSignedModel Parse(ICardCrypto cardCrypto, Card card)
{
ValidateParams(cardCrypto, card);
var rawSignedModel = Generate(
cardCrypto,
new CardParams()
{
Identity = card.Identity,
PreviousCardId = card.PreviousCardId,
PublicKey = card.PublicKey
},
card.CreatedAt);
rawSignedModel.Signatures = new List <RawSignature>();
foreach (var signature in card.Signatures)
{
rawSignedModel.Signatures.Add(
new RawSignature()
{
Signature = signature.Signature,
Signer = signature.Signer,
Snapshot = signature.Snapshot
}
);
}
return(rawSignedModel);
}
/// <summary>
/// Initializes a new instance of the <see cref="VirgilCardVerifier"/> class.
/// </summary>
/// <param name="crypto">The instance of <see cref="ICardCrypto"/> that is
/// used for signature verification.</param>
public VirgilCardVerifier(ICardCrypto crypto)
{
this.whiteLists = new List <Whitelist>();
this.cardCrypto = crypto;
this.VerifySelfSignature = true;
this.VerifyVirgilSignature = true;
}
/// <summary>
/// Loads <see cref="Card"/> from the specified <see cref="RawSignedModel"/>.
/// </summary>
/// <param name="cardCrypto">an instance of <see cref="ICardCrypto"/>.</param>
/// <param name="rawSignedModel">an instance of <see cref="RawSignedModel"/> to get
/// <see cref="Card"/> from.</param>
/// <param name="isOutdated"></param>
/// <returns>Loaded instance of <see cref="Card"/>.</returns>
public static Card Parse(ICardCrypto cardCrypto, RawSignedModel rawSignedModel, bool isOutdated = false)
{
ValidateParams(cardCrypto, rawSignedModel);
var rawCardContent = SnapshotUtils.ParseSnapshot <RawCardContent>(rawSignedModel.ContentSnapshot);
var signatures = new List <CardSignature>();
if (rawSignedModel.Signatures != null)
{
foreach (var s in rawSignedModel.Signatures)
{
var cardSignature = new CardSignature
{
Signer = s.Signer,
Signature = s.Signature,
ExtraFields = TryParseExtraFields(s.Snapshot),
Snapshot = s.Snapshot
};
signatures.Add(cardSignature);
}
}
return(new Card(
GenerateCardId(cardCrypto, rawSignedModel.ContentSnapshot),
rawCardContent.Identity,
cardCrypto.ImportPublicKey(rawCardContent.PublicKey),
rawCardContent.Version,
rawCardContent.CreatedAt,
signatures,
rawCardContent.PreviousCardId,
rawSignedModel.ContentSnapshot,
isOutdated
));
}
public static string GenerateCardId(ICardCrypto cardCrypto, byte[] snapshot)
{
ValidateGenerateCardIdParams(cardCrypto, snapshot);
var fingerprint = cardCrypto.GenerateSHA512(snapshot);
var id = Bytes.ToString(fingerprint.Take(32).ToArray(), StringEncoding.HEX);
return(id);
}
public static IList <Card> Parse(ICardCrypto cardCrypto, IEnumerable <RawSignedModel> requests)
{
if (requests == null)
{
throw new ArgumentNullException(nameof(requests));
}
return(requests.Select(r => CardUtils.Parse(cardCrypto, r)).ToList());
}
private static void ValidateParams(ICardCrypto cardCrypto, Card rawSignedModel)
{
if (rawSignedModel == null)
{
throw new ArgumentNullException(nameof(rawSignedModel));
}
if (cardCrypto == null)
{
throw new ArgumentNullException(nameof(cardCrypto));
}
}
private static void ValidateGenerateCardIdParams(ICardCrypto cardCrypto, byte[] snapshot)
{
if (cardCrypto == null)
{
throw new ArgumentNullException(nameof(cardCrypto));
}
if (snapshot == null)
{
throw new ArgumentNullException(nameof(snapshot));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CardManager"/> class by
/// a specified set of parameters.
/// </summary>
/// <param name="params">the instance of <see cref="CardManagerParams"/>. </param>
public CardManager(CardManagerParams @params)
{
ValidateCardManagerParams(@params);
this.CardCrypto = @params.CardCrypto;
this.AccessTokenProvider = @params.AccessTokenProvider;
this.Client = string.IsNullOrWhiteSpace(@params.ApiUrl)
? new CardClient()
: new CardClient(@params.ApiUrl);
this.CardVerifier = @params.Verifier;
this.ModelSigner = new ModelSigner(CardCrypto);
this.SignCallBack = @params.SignCallBack;
this.RetryOnUnauthorized = @params.RetryOnUnauthorized;
}
internal static RawSignedModel Generate(
ICardCrypto cardCrypto,
CardParams @params,
DateTime createdAt)
{
ValidateGenerateParams(cardCrypto, @params);
var details = new RawCardContent
{
Identity = @params.Identity,
PublicKey = cardCrypto.ExportPublicKey(@params.PublicKey),
Version = CardVersion,
CreatedAt = createdAt,
PreviousCardId = @params.PreviousCardId
};
return(new RawSignedModel()
{
ContentSnapshot = SnapshotUtils.TakeSnapshot(details)
});
}
private static void ValidateGenerateParams(ICardCrypto cardCrypto, CardParams @params)
{
if (cardCrypto == null)
{
throw new ArgumentNullException(nameof(cardCrypto));
}
if (@params == null)
{
throw new ArgumentNullException(nameof(@params));
}
if (@params.Identity == null)
{
throw new ArgumentException($"{nameof(@params.Identity)} property is mandatory");
}
if (@params.PublicKey == null)
{
throw new ArgumentException($"{nameof(@params.PublicKey)} property is mandatory");
}
}
public ModelSigner(ICardCrypto crypto)
{
this.Crypto = crypto;
}
