public object Build(KeyedDescription description)
{
if (!ShouldBuildDescription(description))
{
return(null);
}
var key = string.IsNullOrEmpty(description.Key) ? DefaultKey : description.Key;
Type type;
if (!KnownKeys.TryGetValue(key, out type))
{
throw new KeyNotFoundException("Could not find class for " + description.Key);
}
var constructor = type.GetConstructors()
.FirstOrDefault(c => c.GetParameters().All(p => p.IsOptional));
if (constructor == null)
{
throw new ArgumentException("No parameterless Constructor found for " + key);
}
// due to Mono and WP implementation issues, we don't use Type.Missing
//var parameters = constructor.GetParameters().Select(p => (object)Type.Missing).ToArray();
var parameters = constructor.GetParameters().Select(p => p.DefaultValue).ToArray();
var instance = constructor.Invoke(null, parameters);
return(instance);
}
} // 'SZDD'
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.Position = 0xE;
using (var lz = OpenCrzStream(file))
{
int max_header_length = KnownKeys.Keys.Max(x => x.Length);
var header = new byte[max_header_length + 0x35];
lz.Read(header, 0, header.Length);
var id = Binary.GetCString(header, 0, max_header_length);
byte[] key;
if (!KnownKeys.TryGetValue(id, out key))
{
return(null);
}
int seed_pos = id.Length + 1;
int header_pos = seed_pos + 0x10;
for (int i = 0; i < 0x24; ++i)
{
header[header_pos + i] ^= (byte)(key[i] ^ header[seed_pos + (i & 0xF)]);
}
return(new CrzMetaData {
Width = header.ToUInt32(header_pos + 4),
Height = header.ToUInt32(header_pos + 0x10),
BPP = 16,
HeaderSize = header.ToInt32(header_pos + 0x18) + 0x34 + seed_pos
});
}
}
public static void TestAddNewKnownKey()
{
KnownKeys knownKeys = new KnownKeys();
AesKey key = new AesKey();
knownKeys.Add(key);
Assert.That(knownKeys.Keys.First(), Is.EqualTo(key), "The first and only key should be the one just added.");
}
byte[] GetKeyForTitle(string title)
{
byte[] key = null;
if (!string.IsNullOrEmpty(title))
{
KnownKeys.TryGetValue(title, out key);
}
return(key);
}
public static byte[] GetKey(string title)
{
byte[] key;
if (string.IsNullOrEmpty(title) || !KnownKeys.TryGetValue(title, out key))
{
return(null);
}
return(key);
}
static byte[] GetKeyData(string scheme)
{
byte[] key;
if (KnownKeys.TryGetValue(scheme, out key))
{
return(key);
}
return(null);
}
public static void TestDefaultEncryptionKey()
{
KnownKeys knownKeys = new KnownKeys();
AesKey key = new AesKey();
knownKeys.DefaultEncryptionKey = key;
Assert.That(knownKeys.DefaultEncryptionKey, Is.EqualTo(key), "The DefaultEncryptionKey should be the one just set as it.");
Assert.That(knownKeys.Keys.Count(), Is.EqualTo(1), "Only one key should be in the collection.");
Assert.That(knownKeys.Keys.First(), Is.EqualTo(key), "The first and only key should be the one just set as DefaultEncryptionKey.");
}
internal uint QueryKey()
{
if (!KnownKeys.Any())
{
return(0);
}
var options = Query <GalOptions> (arcStrings.ArcImageEncrypted);
return(options.Key);
}
public static void TestAddSameKeyTwice()
{
KnownKeys knownKeys = new KnownKeys();
AesKey key = new AesKey();
knownKeys.Add(key);
knownKeys.Add(key);
Assert.That(knownKeys.Keys.Count(), Is.EqualTo(1), "Only one key should be in the collection even if added twice.");
Assert.That(knownKeys.Keys.First(), Is.EqualTo(key), "The first and only key should be the one just added.");
}
uint GetAsbKey(string scheme)
{
uint key;
if (KnownKeys.TryGetValue(scheme, out key))
{
return(key);
}
return(0);
}
public static void TestAddTwoNewKnownKeys()
{
KnownKeys knownKeys = new KnownKeys();
AesKey key1 = new AesKey();
knownKeys.Add(key1);
AesKey key2 = new AesKey();
knownKeys.Add(key2);
Assert.That(knownKeys.Keys.First(), Is.EqualTo(key2), "The first key should be the last one added.");
Assert.That(knownKeys.Keys.Last(), Is.EqualTo(key1), "The last key should be the first one added.");
}
public static void TestClear()
{
KnownKeys knownKeys = new KnownKeys();
AesKey key1 = new AesKey();
knownKeys.Add(key1);
AesKey key2 = new AesKey();
knownKeys.Add(key2);
Assert.That(knownKeys.Keys.Count(), Is.EqualTo(2), "There should be two keys in the collection.");
knownKeys.Clear();
Assert.That(knownKeys.Keys.Count(), Is.EqualTo(0), "There should be zero keys in the collection after Clear().");
}
public static void TestSettingNullDefaultEncryptionKey()
{
KnownKeys knownKeys = new KnownKeys();
AesKey key1 = new AesKey();
knownKeys.Add(key1);
AesKey key2 = new AesKey();
knownKeys.DefaultEncryptionKey = key2;
Assert.That(knownKeys.Keys.Count(), Is.EqualTo(2), "Setting the DefaultEncryptionKey should also add it as a known key.");
knownKeys.DefaultEncryptionKey = null;
Assert.That(knownKeys.Keys.Count(), Is.EqualTo(2), "Setting the DefaultEncryptionKey to null should not affect the known keys.");
}
public static void TestChangedEvent()
{
bool wasChanged = false;
KnownKeys knownKeys = new KnownKeys();
knownKeys.Changed += (object sender, EventArgs e) =>
{
wasChanged = true;
};
AesKey key1 = new AesKey();
knownKeys.Add(key1);
Assert.That(wasChanged, Is.True, "A new key should trigger the Changed event.");
wasChanged = false;
knownKeys.Add(key1);
Assert.That(wasChanged, Is.False, "Re-adding an existing key should not trigger the Changed event.");
}
byte[] QueryEncryption(ArcView file)
{
var title = FormatCatalog.Instance.LookupGame(file.Name, @"..\*.exe");
byte[] key = null;
if (!string.IsNullOrEmpty(title) && KnownKeys.ContainsKey(title))
{
return(KnownKeys[title]);
}
if (null == key)
{
key = GuessKeyData(file.Name);
}
if (null == key)
{
var options = Query <QlieOptions> (arcStrings.ArcEncryptedNotice);
key = options.GameKeyData;
}
return(key);
}
} // 'SZDD'
public override ImageMetaData ReadMetaData(IBinaryStream file)
{
file.Position = 0xE;
using (var lz = new LzssStream(file.AsStream, LzssMode.Decompress, true))
{
lz.Config.FrameSize = 0x1000;
lz.Config.FrameFill = 0x20;
lz.Config.FrameInitPos = 0x1000 - 0x10;
var header = new byte[0x24];
if (0x11 != lz.Read(header, 0, 0x11))
{
return(null);
}
var key = KnownKeys.Where(x => header.AsciiEqual(x.Key)).Select(x => x.Value).FirstOrDefault();
if (null == key)
{
return(null);
}
var seed = new byte[0x10];
lz.Read(seed, 0, 0x10);
lz.Read(header, 0, 0x24);
for (int i = 0; i < 0x24; ++i)
{
header[i] ^= key[i];
}
for (int i = 0; i < 0x24; ++i)
{
header[i] ^= seed[i & 0xF];
}
return(new CrzMetaData {
Width = header.ToUInt32(4),
Height = header.ToUInt32(0x10),
BPP = 16,
HeaderSize = header.ToInt32(0x18) + 0x45
});
}
}
byte[] ReadIndex(string bmi_name)
{
var index = File.ReadAllBytes(bmi_name);
uint signature = index.ToUInt32(0);
string passkey;
if (!KnownKeys.TryGetValue(signature, out passkey))
{
var root = Path.GetPathRoot(bmi_name);
if (string.IsNullOrEmpty(root))
{
return(null);
}
uint serial;
if (!GetVolumeInformation(root, IntPtr.Zero, 0, out serial,
IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, 0))
{
return(null);
}
passkey = string.Format("{0:x4}{1}", serial, (int)serial);
}
uint seed = GetSeedFromString(passkey);
var twister = new MersenneTwister(seed);
unsafe
{
fixed(byte *idx8 = index)
{
uint *dst = (uint *)idx8;
for (int n = index.Length / 4; n > 0; --n)
{
*dst++ ^= twister.Rand();
}
}
}
return(index);
}
byte[] GetKey(string title)
{
byte[] key;
KnownKeys.TryGetValue(title, out key);
return(key);
}
private void Initialize(StreamingContext context)
{
_lock = new object();
KnownKeys = new KnownKeys();
}