/// <summary>
/// Value equality for two IKey's
/// </summary>
/// <returns>true if all parts of of the keys are the same</returns>
public static bool EqualTo(this IKey key, IKey other)
{
return (key.Base == other.Base)
&& (key.TypeName == other.TypeName)
&& (key.ResourceId == other.ResourceId)
&& (key.VersionId == other.VersionId);
}
public BTree(uint topSid, SegmentManager sm, IKey keyFactory)
{
this.m_top_sid = topSid;
this.m_sgManager = sm;
this.m_keyFactory = keyFactory;
this.m_nodeFactory = new BNode();
}
public void AddKey(IKey key)
{
lock (this)
{
_keys.AddLast(key.Key);
}
}
public bool TryGet(IKey key, out IEntry entry)
{
Entry tempEntry;
var result = _entries.TryGetValue(key, out tempEntry) && !tempEntry.IsReserved;
entry = result ? tempEntry : null;
return result;
}
public bool deletePair(IKey key, bool firstCall = false)
{
bool canRemoveKey = true;
if(firstCall)
canRemoveKey = m_rkm.removeKey(key);
if (!canRemoveKey)
return false;
bool retVal = m_pairsManager.removePair(key);
//the key is in the local server
if (retVal)
{
m_pairsManager.saveToDisk();
return retVal;
}
//if key doesn't exists on the server need ask the ring for it
String serviceAddress = m_nextServer.Channel + "://" + m_nextServer.ServerAddress + ":" + m_nextServer.ServerPort + "/" + m_nextServer.ServiceName;
//Creating server proxy
IServer svc = (IServer)Activator.GetObject(
typeof(IServer),
serviceAddress);
try
{
return svc.deletePair(key);
}
catch (Exception)
{
m_rkm.removeServerFromRKM(m_nextServer);
return false;
}
}
public void DeletePair(IKey key)
{
if (_manager.Trykey(key))
{
if (_hashtable.ContainsKey(key.Key))
{
_manager.RemoveKey(key);
_hashtable.Remove(key.Key);
}
else
{
bool b = true;
while (b)
{
try
{
if (_nextserverUri == null) return;
_mysuccessorServer.DeletePair(key);
b = false;
}
catch (Exception ex)
{
if (ex is WebException || ex is RemotingException)
{
_manager.RemakeRing(_nextserverUri);
}
}
}
}
}
}
async Task<RegisterOperationResult?> TryOneRequest(IKey key, KeyRegisterRequest request,
CancellationToken cancellationToken)
{
try
{
var result = await key.RegisterAsync(request, cancellationToken);
log.Info(result.Status.ToString());
switch (result.Status)
{
case KeyResponseStatus.Success:
return RegisterOperationResult.Success(request, result.Data);
}
}
catch (KeyGoneException)
{
// No sense in continuing with this signer, the key isn't physically present anymore
log.DebugFormat("Key '{0}' is gone", keyId);
throw;
}
catch (TaskCanceledException)
{
// Let cancellation bubble up
throw;
}
catch (KeyBusyException)
{
// Maybe it won't be busy later
}
catch (Exception exception)
{
log.Error("Authenticate request failed", exception);
}
return null;
}
public static void HasTypeName(IKey key)
{
if (string.IsNullOrEmpty(key.TypeName))
{
throw Error.BadRequest("Resource type is missing: {0}", key);
}
}
public void Setup()
{
var mappingSet = ModelSetup.SetupModel();
database = mappingSet.Database;
table = database.Tables[0];
key = table.Keys[0];
}
public virtual EntityKeyFactory GetKeyFactory(IKey key)
=> _cache.GetOrAdd(
key,
k =>
{
if (k.Properties.Count == 1)
{
var keyProperty = k.Properties[0];
var keyType = keyProperty.ClrType;
// Use composite key for anything with structural (e.g. byte[]) properties even if they are
// not composite because it is setup to do structural comparisons and the generic typing
// advantages of the simple key don't really apply anyway.
if (!typeof(IStructuralEquatable).GetTypeInfo().IsAssignableFrom(keyType.GetTypeInfo()))
{
var sentinel = keyProperty.SentinelValue;
return (EntityKeyFactory)(sentinel == null
? Activator.CreateInstance(
typeof(SimpleNullSentinelEntityKeyFactory<>).MakeGenericType(keyType.UnwrapNullableType()), k)
: Activator.CreateInstance(
typeof(SimpleEntityKeyFactory<>).MakeGenericType(keyType.UnwrapNullableType()), k, sentinel));
}
}
return new CompositeEntityKeyFactory(k);
});
public IEntry Get(IKey key)
{
IEntry entry;
if (TryGet(key, out entry))
return entry;
throw new EntryNotFoundException(key);
}
public bool TryRemove(IKey key)
{
var fragments = _fragments;
foreach (var fragment in fragments)
if (fragment.TableOfContent.Contains(key))
return fragment.TryRemove(key);
return false;
}
public bool TryGet(IKey key, out IEntry entry)
{
foreach (var fragment in _fragments)
if (fragment.TableOfContent.TryGet(key, out entry))
return true;
entry = null;
return false;
}
public KeyInteractionEventArgs( IKey k, IKeyProgram p, KeyInteractionEventType eventType )
: base(k)
{
EventType = eventType;
// Clone the commands: the emitted commands is a snapshot of the commands
// at the time of the event.
string[] copy = p.Commands.ToArray();
Commands = new CKReadOnlyListOnIList<string>( copy );
}
/// <summary>
/// Initializes a new instance of the <see cref="Message" /> class.
/// </summary>
/// <param name="messageType">Type of the message.</param>
/// <param name="classId">The class identifier.</param>
/// <param name="commandId">The message identifier.</param>
protected Message(MessageType messageType, ClassId classId, byte commandId)
{
_key = new Key(new Identifier(messageType, TechnologyType.Bluetooth_4_0_Single_Mode, classId, commandId));
_header.MessageType = messageType;
_header.TechnologyType = TechnologyType.Bluetooth_4_0_Single_Mode;
_header.ClassId = classId;
_header.CommandId = commandId;
}
public override void Add(string name, IKey key)
{
string keyPath = Path.Combine (this.path, name);
if (File.Exists (keyPath + privateSuffix) || File.Exists (keyPath + publicSuffix))
throw new ArgumentException ("Key with that name already exists");
WriteKey (key, name);
}
public override IEnumerable<IAnnotation> For(IKey key)
{
if (key.SqlServer().IsClustered.HasValue)
{
yield return new Annotation(
SqlServerAnnotationNames.Prefix + SqlServerAnnotationNames.Clustered,
key.SqlServer().IsClustered.Value);
}
}
protected void Set(IKey key)
{
Id = key.Id;
OwnerUserId = key.OwnerUserId;
BlobId = key.BlobId;
Secure = key.Secure;
if (key.KeyData != null)
KeyData = (byte[])key.KeyData.Clone();
}
private void put(IKey key, int level, IEnumerable<Resource> resources)
{
if (resources == null) return;
foreach (var resource in resources)
{
if (resource is DomainResource)
put(key, level, resource as DomainResource);
}
}
public bool TryGet(IKey key, out byte[] content)
{
foreach (var fragment in _fragments)
if (fragment.TryGet(key, out content))
return true;
content = null;
return false;
}
protected static Collection<Dictionary<string, string>> ValidateDtoData(IKey dto, EntityBase entity)
{
var retVal = new Collection<Dictionary<string, string>>();
var fieldName = string.Empty;
foreach (var inputField in dto.GetType().GetProperties().Where(x => x.Name != "Key" && x.GetValue(dto) != null)) {
if (inputField.Name.StartsWith("Start_")) {
fieldName = inputField.Name.Substring(6);
} else if(inputField.Name.StartsWith("End_")){
fieldName = inputField.Name.Substring(4);
} else if(inputField.Name.Contains("__")) {
// using field from a different table
// not currently handling this case
} else {
fieldName = inputField.Name;
}
// insure the entity contains the field represented by fieldName
var entityFieldName = entity.GetType().GetProperty(fieldName);
if (entityFieldName == null || entityFieldName.Name.Length == 0) {
// entity does not contain this field
continue;
}
if (entity.GetDataType(fieldName) == typeof(string)) {
// should be ok
continue;
}
if (entity.GetDataType(fieldName) == typeof(int) || entity.GetDataType(fieldName) == typeof(int?)) {
var nbr = 0;
if (!int.TryParse(inputField.GetValue(dto).ToString(), out nbr)) {
var dic = new Dictionary<string, string> {{inputField.Name, "Invalid data type cast"}};
retVal.Add(dic);
}
if (entity.GetDataType(fieldName) == typeof(bool) || entity.GetDataType(fieldName) == typeof(bool?)) {
if (inputField.GetValue(dto).ToString().ToLower() != "true" && inputField.GetValue(dto).ToString().ToLower() != "false") {
var dic = new Dictionary<string, string> { { inputField.Name, "Invalid data type cast" } };
retVal.Add(dic);
}
}
if (entity.GetDataType(fieldName) == typeof(DateTime) || entity.GetDataType(fieldName) == typeof(DateTime?)) {
DateTime dt;
if (!DateTime.TryParse(inputField.GetValue(dto).ToString(), out dt)) {
var dic = new Dictionary<string, string> { { inputField.Name, "Invalid data type cast" } };
retVal.Add(dic);
}
}
if (entity.GetDataType(fieldName) == typeof(decimal) || entity.GetDataType(fieldName) == typeof(decimal?)) {
decimal d;
if (!decimal.TryParse(inputField.GetValue(dto).ToString(), out d)) {
var dic = new Dictionary<string, string> { { inputField.Name, "Invalid data type cast" } };
retVal.Add(dic);
}
}
}
}
return retVal;
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public override IEnumerable<IAnnotation> For(IKey key)
{
var isClustered = key.SqlServer().IsClustered;
if (isClustered.HasValue)
{
yield return new Annotation(
SqlServerFullAnnotationNames.Instance.Clustered,
isClustered.Value);
}
}
private void put(IKey key, int level, Resource resource)
{
if (resource is DomainResource)
{
DomainResource d = resource as DomainResource;
put(key, level, d);
put(key, level + 1, d.Contained);
}
}
private static void Key150To160( IPluginConfigAccessor simpleSkinConfigAccessor, IKey k )
{
//Prior to SimpleSkin plugin v1.6.0 the images were stored in the plugin datas of the layoutkeymodes
//Since this version, the images are on the keymodes
foreach( var layoutKeyMode in k.CurrentLayout.LayoutKeyModes )
{
PropertyMigrationLayoutKeyModeToKeyMode( simpleSkinConfigAccessor, layoutKeyMode, "Image" );
PropertyMigrationLayoutKeyModeToKeyMode( simpleSkinConfigAccessor, layoutKeyMode, "DisplayType" );
}
}
internal static void Key150To160( IKey k )
{
//Should be in CK.Keyboard
foreach( var keyMode in k.KeyModes )
{
ProcessKeyProgram150To160( keyMode.OnKeyDownCommands );
ProcessKeyProgram150To160( keyMode.OnKeyUpCommands );
ProcessKeyProgram150To160( keyMode.OnKeyPressedCommands );
}
}
public IList<string> History(IKey key, DateTimeOffset? since = null)
{
var clauses = new List<IMongoQuery>();
clauses.Add(MonQ.Query.EQ(Field.TYPENAME, key.TypeName));
clauses.Add(MonQ.Query.EQ(Field.RESOURCEID, key.ResourceId));
if (since != null)
clauses.Add(MonQ.Query.GT(Field.WHEN, BsonDateTime.Create(since)));
return FetchPrimaryKeys(clauses);
}
public static SparkException NotFound(IKey key)
{
if (key.VersionId == null)
{
return NotFound("No {0} resource with id {1} was found.", key.TypeName, key.ResourceId);
}
else
{
return NotFound("There is no {0} resource with id {1}, or there is no version {2}", key.TypeName, key.ResourceId, key.VersionId);
}
}
public override void Add(string name, IKey key)
{
if (key is PrivateKey) {
privateKeys.Add (name, (PrivateKey)key);
if (DefaultKey == null)
DefaultKey = (PrivateKey)key;
publicKeys.Add (name, ((PrivateKey)key).PublicKey);
} else {
publicKeys.Add (name, (PublicKey)key);
}
}
public static void HasResourceId(IKey key)
{
if (key.HasResourceId())
{
Validate.ResourceId(key.ResourceId);
}
else
{
throw Error.BadRequest("The request should have a resource id.");
}
}
private static void TestValue(IKey key, string fkey)
{
var url = key.GetFileUrl(fkey);
var inverseKey = key.GetFileKeyFromFileUrl(url);
//Assert.AreEqual(fkey, inverseKey);
Assert.AreEqual(fkey.Substring(1), inverseKey.Substring(1));
Assert.AreEqual(key.GetFileUrl(fkey), key.GetFileUrl(inverseKey));
}
/// <summary>
/// Creates a deleted entry
/// </summary>
public static Entry DELETE(IKey key, DateTimeOffset?when)
{
return(Entry.Create(Bundle.HTTPVerb.DELETE, key, DateTimeOffset.UtcNow));
}
public static Entry PUT(IKey key, Resource resource)
{
return(Entry.Create(Bundle.HTTPVerb.PUT, key, resource));
}
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public virtual IUpdateEntry TryGetEntry(IKey key, object[] keyValues) => _stateManager.TryGetEntry(key, keyValues);
public TypeReferanceFinalizeScope(IKey key, ISetUpTypeReference type)
{
this.key = key ?? throw new ArgumentNullException(nameof(key));
SetUpSideNode = type ?? throw new ArgumentNullException(nameof(type));
}
public TypeReferanceResolveReference(IKey key)
{
this.key = key ?? throw new ArgumentNullException(nameof(key));
}
public bool BindingExists(IKey key)
{
return(_bindings.ContainsKey(key));
}
public static Entry Create(Bundle.HTTPVerb method, IKey key, Resource resource)
{
return(new Entry(method, key, null, resource));
}
public static RelationalKeyAnnotations MySQL(this IKey key)
{
ThrowIf.Argument.IsNull(key, "key");
return(new RelationalKeyAnnotations(key, MySQLFullAnnotationNames.Instance));
}
public CurrencyList(IKey key, IEnumerable <IEvent> events)
: base(key, events)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="TableEncryptionPolicy"/> class with the specified key and resolver.
/// </summary>
/// <param name="key">An object of type <see cref="IKey"/> that is used to wrap/unwrap the content encryption key.</param>
/// <param name="keyResolver">The key resolver used to select the correct key for decrypting existing table entities.</param>
/// <remarks>If the generated policy is to be used for encryption, users are expected to provide a key at the minimum.
/// The absence of key will cause an exception to be thrown during encryption.<br/>
/// If the generated policy is intended to be used for decryption, users can provide a key resolver. The client library will:<br/>
/// 1. Invoke the key resolver, if specified, to get the key.<br/>
/// 2. If resolver is not specified but a key is specified, the client library will match the key ID against the key and use the key.</remarks>
public TableEncryptionPolicy(IKey key, IKeyResolver keyResolver)
{
this.Key = key;
this.KeyResolver = keyResolver;
}
internal byte[] DecryptMetadataAndReturnCEK(string partitionKey, string rowKey, EntityProperty encryptionKeyProperty, EntityProperty propertyDetailsProperty, out EncryptionData encryptionData)
{
// Throw if neither the key nor the resolver are set.
if (this.Key == null && this.KeyResolver == null)
{
throw new StorageException(SR.KeyAndResolverMissingError, null)
{
IsRetryable = false
};
}
try
{
encryptionData = JsonConvert.DeserializeObject <EncryptionData>(encryptionKeyProperty.StringValue);
CommonUtility.AssertNotNull("ContentEncryptionIV", encryptionData.ContentEncryptionIV);
CommonUtility.AssertNotNull("EncryptedKey", encryptionData.WrappedContentKey.EncryptedKey);
// Throw if the encryption protocol on the entity doesn't match the version that this client library understands
// and is able to decrypt.
if (encryptionData.EncryptionAgent.Protocol != Constants.EncryptionConstants.EncryptionProtocolV1)
{
throw new StorageException(SR.EncryptionProtocolVersionInvalid, null)
{
IsRetryable = false
};
}
byte[] contentEncryptionKey = null;
// 1. Invoke the key resolver if specified to get the key. If the resolver is specified but does not have a
// mapping for the key id, an error should be thrown. This is important for key rotation scenario.
// 2. If resolver is not specified but a key is specified, match the key id on the key and and use it.
// Calling UnwrapKeyAsync synchronously is fine because for the storage client scenario, unwrap happens
// locally. No service call is made.
if (this.KeyResolver != null)
{
IKey keyEncryptionKey = this.KeyResolver.ResolveKeyAsync(encryptionData.WrappedContentKey.KeyId, CancellationToken.None).Result;
CommonUtility.AssertNotNull("keyEncryptionKey", keyEncryptionKey);
contentEncryptionKey = keyEncryptionKey.UnwrapKeyAsync(encryptionData.WrappedContentKey.EncryptedKey, encryptionData.WrappedContentKey.Algorithm, CancellationToken.None).Result;
}
else
{
if (this.Key.Kid == encryptionData.WrappedContentKey.KeyId)
{
contentEncryptionKey = this.Key.UnwrapKeyAsync(encryptionData.WrappedContentKey.EncryptedKey, encryptionData.WrappedContentKey.Algorithm, CancellationToken.None).Result;
}
else
{
throw new StorageException(SR.KeyMismatch, null)
{
IsRetryable = false
};
}
}
// Decrypt the property details set and add it to entity properties.
#if WINDOWS_DESKTOP && !WINDOWS_PHONE
using (AesCryptoServiceProvider myAes = new AesCryptoServiceProvider())
{
using (SHA256CryptoServiceProvider sha256 = new SHA256CryptoServiceProvider())
#else
using (AesManaged myAes = new AesManaged())
{
using (SHA256Managed sha256 = new SHA256Managed())
#endif
{
byte[] metadataIV = sha256.ComputeHash(CommonUtility.BinaryAppend(encryptionData.ContentEncryptionIV, Encoding.UTF8.GetBytes(string.Join(partitionKey, rowKey, Constants.EncryptionConstants.TableEncryptionPropertyDetails))));
Array.Resize <byte>(ref metadataIV, 16);
myAes.IV = metadataIV;
myAes.Key = contentEncryptionKey;
using (ICryptoTransform transform = myAes.CreateDecryptor())
{
byte[] src = propertyDetailsProperty.BinaryValue;
propertyDetailsProperty.BinaryValue = transform.TransformFinalBlock(src, 0, src.Length);
}
}
}
return(contentEncryptionKey);
}
catch (JsonException ex)
{
throw new StorageException(SR.EncryptionMetadataError, ex)
{
IsRetryable = false
};
}
catch (StorageException)
{
throw;
}
catch (Exception ex)
{
throw new StorageException(SR.DecryptionLogicError, ex)
{
IsRetryable = false
};
}
}
public string GetPredicate(IKey dto, EntityBase entity, string companyId)
{
var sb = new StringBuilder();
var fld = dto.GetType().GetProperty("CompanyID");
if (fld != null)
{
var type = entity.GetDataType("CompanyID");
if (type == typeof(string))
{
sb.Append(string.Format("{0}{1}{2}", "CompanyID", "==", companyId));
}
if (type == typeof(int?))
{
sb.Append(string.Format("{0}{1}{2}{3}", "CompanyID", ".Value", "==", companyId));
}
}
foreach (var field in dto.GetType().GetProperties().Where(x => x.Name != "Key" && x.GetValue(dto) != null))
{
var value = field.GetValue(dto).ToString();
if (!string.IsNullOrEmpty(value))
{
if (sb.Length > 0)
{
sb.Append(" && ");
}
if (field.Name.Contains("__"))
{
// embedded table.field reference
sb.Append(FormatEmbeddedReference(field, field.GetValue(dto).ToString()));
}
else
{
var fieldName = string.Empty;
if (field.Name.StartsWith("Start_"))
{
fieldName = field.Name.Substring(6);
}
else if (field.Name.StartsWith("End_"))
{
fieldName = field.Name.Substring(4);
}
else
{
fieldName = field.Name;
}
var type = entity.GetDataType(fieldName);
if (type == typeof(string))
{
sb.Append(fieldName + ".Contains('");
sb.Append(String.Format("{0}{1}", field.GetValue(dto), "')"));
//sb.Append(field.GetValue(dto) + ")");
continue;
}
if (type == typeof(int))
{
sb.Append(string.Format("{0}{1}{2}", fieldName, "==", int.Parse(field.GetValue(dto).ToString())));
continue;
}
if (type == typeof(int?))
{
sb.Append(string.Format("{0}{1}{2}{3}", fieldName, ".Value", "==", int.Parse(field.GetValue(dto).ToString())));
continue;
}
if (type == typeof(bool))
{
sb.Append(string.Format("{0}{1}{2}", fieldName, "==", bool.Parse(field.GetValue(dto).ToString())));
continue;
}
if (type == typeof(bool?))
{
sb.Append(string.Format("{0}{1}{2}{3}", fieldName, ".Value", "==", bool.Parse(field.GetValue(dto).ToString())));
continue;
}
if (type == typeof(DateTime?))
{
var comparer = string.Empty;
var date = string.Empty;
if (field.Name.StartsWith("Start_"))
{
comparer = ">";
date = DateTime.Parse(field.GetValue(dto).ToString()).AddDays(-1).ToShortDateString();
}
else
{
comparer = "<";
date = DateTime.Parse(field.GetValue(dto).ToString()).AddDays(1).ToShortDateString();
}
fieldName = fieldName + ".Value";
sb.Append(String.Format("{0}{1}{2}{3}{2}", fieldName, comparer, "'", date));
continue;
}
if (type == typeof(DateTime))
{
var comparer = string.Empty;
var date = string.Empty;
if (field.Name.StartsWith("Start_"))
{
comparer = ">";
date = DateTime.Parse(field.GetValue(dto).ToString()).AddDays(-1).ToShortDateString();
}
else
{
comparer = "<";
date = DateTime.Parse(field.GetValue(dto).ToString()).AddDays(1).ToShortDateString();
}
sb.Append(String.Format("{0}{1}{2}{3}{2}", fieldName, comparer, "'", date));
continue;
}
if (type == typeof(decimal))
{
sb.Append(string.Format("{0}{1}{2}", fieldName, "==", decimal.Parse(field.GetValue(dto).ToString())));
}
if (type == typeof(decimal?))
{
sb.Append(string.Format("{0}{1}{2}{3}", fieldName, ".Value", "==", decimal.Parse(field.GetValue(dto).ToString())));
}
}
}
}
return(sb.ToString());
}
public static Entry Create(Bundle.HTTPVerb method, IKey key, DateTimeOffset when)
{
return(new Entry(method, key, when, null));
}
/// <summary>
/// Return a reference to a <see cref="CryptoStream"/> object, given a user stream. This method is used for decrypting blobs.
/// </summary>
/// <param name="userProvidedStream">The output stream provided by the user.</param>
/// <param name="metadata">A reference to a dictionary containing blob metadata that includes the encryption data.</param>
/// <param name="transform">The <see cref="ICryptoTransform"/> function for the request.</param>
/// <param name="requireEncryption">A boolean value to indicate whether the data read from the server should be encrypted.</param>
/// <param name="iv">The iv to use if pre-buffered. Used only for range reads.</param>
/// <param name="noPadding">Value indicating if the padding mode should be set or not.</param>
/// <returns>A reference to a <see cref="CryptoStream"/> that will be written to.</returns>
internal Stream DecryptBlob(Stream userProvidedStream, IDictionary <string, string> metadata, out ICryptoTransform transform, bool?requireEncryption, byte[] iv = null, bool noPadding = false)
{
CommonUtility.AssertNotNull("metadata", metadata);
string encryptionDataString = null;
// If encryption policy is set but the encryption metadata is absent, throw an exception.
bool encryptionMetadataAvailable = metadata.TryGetValue(Constants.EncryptionConstants.BlobEncryptionData, out encryptionDataString);
if (requireEncryption.HasValue && requireEncryption.Value && !encryptionMetadataAvailable)
{
throw new StorageException(SR.EncryptionDataNotPresentError, null)
{
IsRetryable = false
};
}
try
{
if (encryptionDataString != null)
{
BlobEncryptionData encryptionData = JsonConvert.DeserializeObject <BlobEncryptionData>(encryptionDataString);
CommonUtility.AssertNotNull("ContentEncryptionIV", encryptionData.ContentEncryptionIV);
CommonUtility.AssertNotNull("EncryptedKey", encryptionData.WrappedContentKey.EncryptedKey);
// Throw if the encryption protocol on the blob doesn't match the version that this client library understands
// and is able to decrypt.
if (encryptionData.EncryptionAgent.Protocol != Constants.EncryptionConstants.EncryptionProtocolV1)
{
throw new StorageException(SR.EncryptionProtocolVersionInvalid, null)
{
IsRetryable = false
};
}
// Throw if neither the key nor the resolver are set.
if (this.Key == null && this.KeyResolver == null)
{
throw new StorageException(SR.KeyAndResolverMissingError, null)
{
IsRetryable = false
};
}
byte[] contentEncryptionKey = null;
// 1. Invoke the key resolver if specified to get the key. If the resolver is specified but does not have a
// mapping for the key id, an error should be thrown. This is important for key rotation scenario.
// 2. If resolver is not specified but a key is specified, match the key id on the key and and use it.
// Calling UnwrapKeyAsync synchronously is fine because for the storage client scenario, unwrap happens
// locally. No service call is made.
if (this.KeyResolver != null)
{
IKey keyEncryptionKey = this.KeyResolver.ResolveKeyAsync(encryptionData.WrappedContentKey.KeyId, CancellationToken.None).Result;
CommonUtility.AssertNotNull("KeyEncryptionKey", keyEncryptionKey);
contentEncryptionKey = keyEncryptionKey.UnwrapKeyAsync(encryptionData.WrappedContentKey.EncryptedKey, encryptionData.WrappedContentKey.Algorithm, CancellationToken.None).Result;
}
else
{
if (this.Key.Kid == encryptionData.WrappedContentKey.KeyId)
{
contentEncryptionKey = this.Key.UnwrapKeyAsync(encryptionData.WrappedContentKey.EncryptedKey, encryptionData.WrappedContentKey.Algorithm, CancellationToken.None).Result;
}
else
{
throw new StorageException(SR.KeyMismatch, null)
{
IsRetryable = false
};
}
}
switch (encryptionData.EncryptionAgent.EncryptionAlgorithm)
{
case EncryptionAlgorithm.AES_CBC_256:
#if WINDOWS_DESKTOP && !WINDOWS_PHONE
using (AesCryptoServiceProvider aesProvider = new AesCryptoServiceProvider())
#else
using (AesManaged aesProvider = new AesManaged())
#endif
{
aesProvider.IV = iv != null ? iv : encryptionData.ContentEncryptionIV;
aesProvider.Key = contentEncryptionKey;
if (noPadding)
{
#if WINDOWS_DESKTOP && !WINDOWS_PHONE
aesProvider.Padding = PaddingMode.None;
#endif
}
transform = aesProvider.CreateDecryptor();
return(new CryptoStream(userProvidedStream, transform, CryptoStreamMode.Write));
}
default:
throw new StorageException(SR.InvalidEncryptionAlgorithm, null)
{
IsRetryable = false
};
}
}
else
{
transform = null;
return(userProvidedStream);
}
}
catch (JsonException ex)
{
throw new StorageException(SR.EncryptionMetadataError, ex)
{
IsRetryable = false
};
}
catch (StorageException)
{
throw;
}
catch (Exception ex)
{
throw new StorageException(SR.DecryptionLogicError, ex)
{
IsRetryable = false
};
}
}
public TypeReferancePopulateScope(IKey typeName)
{
key = typeName ?? throw new ArgumentNullException(nameof(typeName));
}
public OutcomeAlreadyHasCategoryException(IKey categoryKey)
: base(string.Format("The outcome already has a category '{0}'.", categoryKey))
{
CategoryKey = categoryKey;
}
private void SaveMovieKey(XElement element, XName attributeName, IKey key)
{
element.SetAttributeValue(attributeName, GetMovieId(key));
}
public static IPopulateScope <WeakTypeReference, ISetUpTypeReference> PopulateScope(IKey typeName)
{
return(new TypeReferancePopulateScope(typeName));
}
/// <summary>
/// Initializes a new instance of the <see cref="BlobEncryptionPolicy"/> class with the specified key and resolver.
/// </summary>
/// <param name="key">An object of type <see cref="IKey"/> that is used to wrap/unwrap the content key during encryption.</param>
/// <param name="keyResolver">The key resolver used to select the correct key for decrypting existing blobs.</param>
/// <remarks>If the generated policy is to be used for encryption, users are expected to provide a key at the minimum.
/// The absence of key will cause an exception to be thrown during encryption.<br/>
/// If the generated policy is intended to be used for decryption, users can provide a key resolver. The client library will:<br/>
/// 1. Invoke the key resolver, if specified, to get the key.<br/>
/// 2. If resolver is not specified but a key is specified, the client library will match the key ID against the key and use the key.</remarks>
public BlobEncryptionPolicy(IKey key, IKeyResolver keyResolver)
{
this.Key = key;
this.KeyResolver = keyResolver;
this.EncryptionMode = BlobEncryptionMode.FullBlob;
}
private async void abbPin_Click(object sender, RoutedEventArgs e)
{
IKey categoryKey = ViewModel.SelectedCategories.FirstOrDefault() ?? KeyFactory.Empty(typeof(Category));
Color? background = null;
string categoryName = null;
// Select a category.
CategoryPicker categoryPicker = new CategoryPicker();
categoryPicker.SelectedKey = categoryKey;
ContentDialogResult categoryResult = await categoryPicker.ShowAsync();
if (categoryResult == ContentDialogResult.None)
{
return;
}
if (categoryResult == ContentDialogResult.Primary)
{
categoryKey = categoryPicker.SelectedKey;
}
else if (categoryResult == ContentDialogResult.Secondary)
{
categoryKey = KeyFactory.Empty(typeof(Category));
}
if (!categoryKey.IsEmpty)
{
CategoryModel category = ViewModel.Categories.FirstOrDefault(c => c.Key.Equals(categoryKey));
if (category != null)
{
categoryName = category.Name;
background = category.Color;
}
}
// Select a background color.
ColorPicker backgroundPicker = new ColorPicker();
backgroundPicker.Title = "Pick a tile background color";
backgroundPicker.PrimaryButtonText = "Create";
if (background != null)
{
backgroundPicker.Value = background.Value;
}
ContentDialogResult backgroundResult = await backgroundPicker.ShowAsync();
if (backgroundResult == ContentDialogResult.None)
{
return;
}
// Create a tile.
await tileService.PinOutcomeCreate(categoryKey, categoryName, backgroundPicker.Value);
string message = "Tile created";
if (categoryName != null)
{
message += $" for category '{categoryName}'";
}
navigator
.Message(message)
.Show();
}
internal CacheableKeyRing(CancellationToken expirationToken, DateTimeOffset expirationTime, IKey defaultKey, IEnumerable <IKey> allKeys)
: this(expirationToken, expirationTime, keyRing : new KeyRing(defaultKey, allKeys))
{
}
public ISigner CreateSigner(IKey key) => new EllipticCurveSigner(key, signingAlgorithm, hashAlgorithm);
protected virtual void OpenOverview(T item, IKey categorykey)
{
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
protected override MethodCallCodeFragment GenerateFluentApi(IKey key, IAnnotation annotation)
=> annotation.Name == SqlServerAnnotationNames.Clustered
? (bool)annotation.Value == false
? new MethodCallCodeFragment(nameof(SqlServerIndexBuilderExtensions.IsClustered), false)
: new MethodCallCodeFragment(nameof(SqlServerIndexBuilderExtensions.IsClustered))
: null;
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual Func <bool, IIdentityMap> Create([NotNull] IKey key)
=> (Func <bool, IIdentityMap>) typeof(IdentityMapFactoryFactory).GetTypeInfo()
.GetDeclaredMethod(nameof(CreateFactory))
.MakeGenericMethod(GetKeyType(key))
.Invoke(null, new object[] { key });
public PrivateMember(IKey key)
{
this.key = key ?? throw new ArgumentNullException(nameof(key));
}
/// <summary> /// Gets all foreign keys that target a given primary or alternate key. /// </summary> /// <param name="key"> The key to find the foreign keys for. </param> /// <returns> The foreign keys that reference the given key. </returns> public static IEnumerable <IForeignKey> GetReferencingForeignKeys([NotNull] this IKey key) => Check.NotNull(key, nameof(key)).AsKey().ReferencingForeignKeys ?? Enumerable.Empty <IForeignKey>();
/// <summary> /// Returns a value indicating whether the key is the primary key. /// </summary> /// <param name="key"> The key to find whether it is primary. </param> /// <returns> <c>true</c> if the key is the primary key. </returns> public static bool IsPrimaryKey([NotNull] this IKey key) => key == key.DeclaringEntityType.FindPrimaryKey();
public override IAccountStateDelta Execute(IActionContext context)
{
IActionContext ctx = context;
var states = ctx.PreviousStates;
if (ctx.Rehearsal)
{
states = states.SetState(ShopState.Address, MarkChanged);
states = states.SetState(sellerAvatarAddress, MarkChanged);
return(states.SetState(ctx.Signer, MarkChanged));
}
var sw = new Stopwatch();
sw.Start();
var started = DateTimeOffset.UtcNow;
Log.Debug("Sell exec started.");
if (price.Sign < 0)
{
throw new InvalidPriceException($"Aborted as the price is less than zero: {price}.");
}
if (!states.TryGetAgentAvatarStates(ctx.Signer, sellerAvatarAddress, out AgentState agentState, out AvatarState avatarState))
{
throw new FailedLoadStateException("Aborted as the avatar state of the signer was failed to load.");
}
sw.Stop();
Log.Debug("Sell Get AgentAvatarStates: {Elapsed}", sw.Elapsed);
sw.Restart();
if (!avatarState.worldInformation.IsStageCleared(GameConfig.RequireClearedStageLevel.ActionsInShop))
{
avatarState.worldInformation.TryGetLastClearedStageId(out var current);
throw new NotEnoughClearedStageLevelException(GameConfig.RequireClearedStageLevel.ActionsInShop, current);
}
Log.Debug("Sell IsStageCleared: {Elapsed}", sw.Elapsed);
sw.Restart();
if (!states.TryGetState(ShopState.Address, out Bencodex.Types.Dictionary shopStateDict))
{
throw new FailedLoadStateException("Aborted as the shop state was failed to load.");
}
Log.Debug("Sell Get ShopState: {Elapsed}", sw.Elapsed);
sw.Restart();
Log.Debug("Execute Sell; seller: {SellerAvatarAddress}", sellerAvatarAddress);
var productId = context.Random.GenerateRandomGuid();
ShopItem shopItem;
void CheckRequiredBlockIndex(ItemUsable itemUsable)
{
if (itemUsable.RequiredBlockIndex > context.BlockIndex)
{
throw new RequiredBlockIndexException($"Aborted as the itemUsable to enhance ({itemId}) is not available yet; it will be available at the block #{itemUsable.RequiredBlockIndex}.");
}
}
ShopItem PopShopItemFromInventory(ItemUsable itemUsable, Costume costume)
{
avatarState.inventory.RemoveNonFungibleItem(itemId);
return(itemUsable is null
? new ShopItem(ctx.Signer, sellerAvatarAddress, productId, price, costume)
: new ShopItem(ctx.Signer, sellerAvatarAddress, productId, price, itemUsable));
}
// Select an item to sell from the inventory and adjust the quantity.
if (avatarState.inventory.TryGetNonFungibleItem <Equipment>(itemId, out var equipment))
{
CheckRequiredBlockIndex(equipment);
// FIXME: Use `equipment.Unequip()`
equipment.equipped = false;
shopItem = PopShopItemFromInventory(equipment, null);
}
else if (avatarState.inventory.TryGetNonFungibleItem <Consumable>(itemId, out var consumable))
{
CheckRequiredBlockIndex(consumable);
avatarState.inventory.RemoveNonFungibleItem(itemId);
shopItem = PopShopItemFromInventory(consumable, null);
}
else if (avatarState.inventory.TryGetNonFungibleItem <Costume>(itemId, out var costume))
{
// FIXME: Use `costume.Unequip()`
costume.equipped = false;
shopItem = PopShopItemFromInventory(null, costume);
}
else
{
throw new ItemDoesNotExistException(
$"Aborted as the NonFungibleItem ({itemId}) was failed to load from avatar's inventory.");
}
IValue shopItemSerialized = shopItem.Serialize();
IKey productIdSerialized = (IKey)productId.Serialize();
Dictionary products = (Dictionary)shopStateDict["products"];
products = (Dictionary)products.Add(productIdSerialized, shopItemSerialized);
shopStateDict = shopStateDict.SetItem("products", products);
sw.Stop();
Log.Debug("Sell Get Register Item: {Elapsed}", sw.Elapsed);
sw.Restart();
avatarState.updatedAt = ctx.BlockIndex;
avatarState.blockIndex = ctx.BlockIndex;
states = states.SetState(sellerAvatarAddress, avatarState.Serialize());
sw.Stop();
Log.Debug("Sell Set AvatarState: {Elapsed}", sw.Elapsed);
sw.Restart();
states = states.SetState(ShopState.Address, shopStateDict);
sw.Stop();
var ended = DateTimeOffset.UtcNow;
Log.Debug("Sell Set ShopState: {Elapsed}", sw.Elapsed);
Log.Debug("Sell Total Executed Time: {Elapsed}", ended - started);
return(states);
}
public static IPopulateBoxes <WeakTypeReference> PopulateBoxes(IKey key)
{
return(new TypeReferanceResolveReference(key));
}
