public void _03_DigestKeyTest()
{
if (Platform.UnmanagedLongSize != 4 || Platform.StructPackingSize != 1)
Assert.Inconclusive("Test cannot be executed on this platform");
using (Pkcs11 pkcs11 = new Pkcs11(Settings.Pkcs11LibraryPath, Settings.AppType))
{
// Find first slot with token present
Slot slot = Helpers.GetUsableSlot(pkcs11);
// Open RW session
using (Session session = slot.OpenSession(SessionType.ReadWrite))
{
// Login as normal user
session.Login(CKU.CKU_USER, Settings.NormalUserPin);
// Generate symetric key
ObjectHandle generatedKey = Helpers.GenerateKey(session);
// Specify digesting mechanism
Mechanism mechanism = new Mechanism(CKM.CKM_SHA_1);
// Digest key
byte[] digest = session.DigestKey(mechanism, generatedKey);
// Do something interesting with digest value
Assert.IsNotNull(digest);
session.DestroyObject(generatedKey);
session.Logout();
}
}
}
/// <summary>
/// Initializes a new instance of the HashAlgorithm class.
/// </summary>
/// <param name="serviceProvider">The name of the service provider which implements the hash algorithm</param>
/// <param name="mechanism">The hash algorithm type</param>
public HashAlgorithm(HashAlgorithmType hashAlgorithm, string serviceProvider = "")
: base(new Session(serviceProvider, (MechanismType)hashAlgorithm), true)
{
m_mechanism = new Mechanism((MechanismType)hashAlgorithm);
m_hashSize = -1;
Initialize();
}
public void _02_DigestMultiPartTest()
{
if (Platform.UnmanagedLongSize != 4 || Platform.StructPackingSize != 1)
Assert.Inconclusive("Test cannot be executed on this platform");
using (Pkcs11 pkcs11 = new Pkcs11(Settings.Pkcs11LibraryPath, Settings.AppType))
{
// Find first slot with token present
Slot slot = Helpers.GetUsableSlot(pkcs11);
// Open RO session
using (Session session = slot.OpenSession(SessionType.ReadOnly))
{
// Specify digesting mechanism
Mechanism mechanism = new Mechanism(CKM.CKM_SHA_1);
byte[] sourceData = ConvertUtils.Utf8StringToBytes("Hello world");
byte[] digest = null;
// Multipart digesting can be used i.e. for digesting of streamed data
using (MemoryStream inputStream = new MemoryStream(sourceData))
{
// Digest data
digest = session.Digest(mechanism, inputStream);
}
// Do something interesting with digest value
Assert.IsTrue(Convert.ToBase64String(digest) == "e1AsOh9IyGCa4hLN+2Od7jlnP14=");
}
}
}
public void _02_EncryptAndDecryptMultiPartTest()
{
Helpers.CheckPlatform();
using (Pkcs11 pkcs11 = new Pkcs11(Settings.Pkcs11LibraryPath, Settings.AppType))
{
// Find first slot with token present
Slot slot = Helpers.GetUsableSlot(pkcs11);
// Open RW session
using (Session session = slot.OpenSession(SessionType.ReadWrite))
{
// Login as normal user
session.Login(CKU.CKU_USER, Settings.NormalUserPin);
// Generate symetric key
ObjectHandle generatedKey = Helpers.GenerateKey(session);
// Generate random initialization vector
byte[] iv = session.GenerateRandom(8);
// Specify encryption mechanism with initialization vector as parameter
Mechanism mechanism = new Mechanism(CKM.CKM_DES3_CBC, iv);
byte[] sourceData = ConvertUtils.Utf8StringToBytes("Our new password");
byte[] encryptedData = null;
byte[] decryptedData = null;
// Multipart encryption can be used i.e. for encryption of streamed data
using (MemoryStream inputStream = new MemoryStream(sourceData), outputStream = new MemoryStream())
{
// Encrypt data
// Note that in real world application we would rather use bigger read buffer i.e. 4096
session.Encrypt(mechanism, generatedKey, inputStream, outputStream, 8);
// Read whole output stream to the byte array so we can compare results more easily
encryptedData = outputStream.ToArray();
}
// Do something interesting with encrypted data
// Multipart decryption can be used i.e. for decryption of streamed data
using (MemoryStream inputStream = new MemoryStream(encryptedData), outputStream = new MemoryStream())
{
// Decrypt data
// Note that in real world application we would rather use bigger read buffer i.e. 4096
session.Decrypt(mechanism, generatedKey, inputStream, outputStream, 8);
// Read whole output stream to the byte array so we can compare results more easily
decryptedData = outputStream.ToArray();
}
// Do something interesting with decrypted data
Assert.IsTrue(ConvertUtils.BytesToBase64String(sourceData) == ConvertUtils.BytesToBase64String(decryptedData));
session.DestroyObject(generatedKey);
session.Logout();
}
}
}
public void _01_GenerateKeyTest()
{
using (Pkcs11 pkcs11 = new Pkcs11(Settings.Pkcs11LibraryPath, Settings.AppType))
{
// Find first slot with token present
Slot slot = Helpers.GetUsableSlot(pkcs11);
// Open RW session
using (Session session = slot.OpenSession(SessionType.ReadWrite))
{
// Login as normal user
session.Login(CKU.CKU_USER, Settings.NormalUserPin);
// Prepare attribute template of new key
List <ObjectAttribute> objectAttributes = new List <ObjectAttribute>();
objectAttributes.Add(new ObjectAttribute(CKA.CKA_CLASS, CKO.CKO_SECRET_KEY));
objectAttributes.Add(new ObjectAttribute(CKA.CKA_KEY_TYPE, CKK.CKK_DES3));
objectAttributes.Add(new ObjectAttribute(CKA.CKA_ENCRYPT, true));
objectAttributes.Add(new ObjectAttribute(CKA.CKA_DECRYPT, true));
// Specify key generation mechanism
Mechanism mechanism = new Mechanism(CKM.CKM_DES3_KEY_GEN);
// Generate key
ObjectHandle objectHandle = session.GenerateKey(mechanism, objectAttributes);
// Do something interesting with generated key
// Destroy object
session.DestroyObject(objectHandle);
session.Logout();
}
}
}
public void SerializeObject_AllPropertiesSetToNonDefault_SerializesValidObject()
{
var sut = new Mechanism
{
Type = "mechanism type",
Description = "mechanism description",
Handled = true,
HelpLink = "https://helplink",
};
sut.Data.Add("data-key", "data-value");
sut.Meta.Add("meta-key", "meta-value");
var actual = sut.ToJsonString();
Assert.Equal(
"{\"data\":{\"data-key\":\"data-value\"}," +
"\"meta\":{\"meta-key\":\"meta-value\"}," +
"\"type\":\"mechanism type\"," +
"\"description\":\"mechanism description\"," +
"\"help_link\":\"https://helplink\"," +
"\"handled\":true}",
actual
);
}
/// <summary>
/// Signs single-part data, where the signature is an appendix to the data
/// </summary>
/// <param name="session">Instance of the extended class</param>
/// <param name="mechanism">Signature mechanism</param>
/// <param name="keyHandle">Signature key</param>
/// <param name="data">Data to be signed</param>
/// <param name="pin">Pin of user</param>
/// <returns>Signature</returns>
public static byte[] Sign(this Session session, Mechanism mechanism, ObjectHandle keyHandle, byte[] data, byte[] pin)
{
if (Platform.UnmanagedLongSize == 4)
{
if (Platform.StructPackingSize == 0)
{
throw new NotImplementedException();
}
else
{
var mechanism41 = (HLA41.Mechanism) typeof(Mechanism).GetField("_mechanism41", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
var keyHandle41 = (HLA41.ObjectHandle) typeof(ObjectHandle).GetField("_objectHandle41", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(keyHandle);
return(session.HLA41Session.Sign(mechanism41, keyHandle41, data, pin));
}
}
else
{
if (Platform.StructPackingSize == 0)
{
throw new NotImplementedException();
}
else
{
throw new NotImplementedException();
}
}
}
/// <summary>
/// Initializes a new instance of the HashAlgorithm class.
/// </summary>
/// <param name="session">The Cryptoki session context the hash algorithm will execute in.</param>
/// <param name="mechanism">The hash algorithm type</param>
public HashAlgorithm(HashAlgorithmType hashAlgorithm, Session session)
: base(session, false)
{
m_mechanism = new Mechanism((MechanismType)hashAlgorithm);
m_hashSize = -1;
Initialize();
}
/// <summary>
/// Creates and Resets a new timer.
/// </summary>
/// <param name="mechanism">The directional mechanism to use.</param>
/// <param name="timeMode">The time counting mode to use.</param>
public UTimer(Mechanism mechanism, TimeMode timeMode)
{
allTimers.Add(this);
this.mechanism = mechanism;
this.timeMode = timeMode;
Reset();
}
public void _02_GenerateKeyPairTest()
{
using (Pkcs11 pkcs11 = new Pkcs11(Settings.Pkcs11LibraryPath, Settings.UseOsLocking))
{
// Find first slot with token present
Slot slot = Helpers.GetUsableSlot(pkcs11);
// Open RW session
using (Session session = slot.OpenSession(false))
{
// Login as normal user
session.Login(CKU.CKU_USER, Settings.NormalUserPin);
// The CKA_ID attribute is intended as a means of distinguishing multiple key pairs held by the same subject
byte[] ckaId = session.GenerateRandom(20);
// Prepare attribute template of new public key
List <ObjectAttribute> publicKeyAttributes = new List <ObjectAttribute>();
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_TOKEN, true));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_PRIVATE, false));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_LABEL, Settings.ApplicationName));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_ID, ckaId));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_ENCRYPT, true));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_VERIFY, true));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_VERIFY_RECOVER, true));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_WRAP, true));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_MODULUS_BITS, 1024));
publicKeyAttributes.Add(new ObjectAttribute(CKA.CKA_PUBLIC_EXPONENT, new byte[] { 0x01, 0x00, 0x01 }));
// Prepare attribute template of new private key
List <ObjectAttribute> privateKeyAttributes = new List <ObjectAttribute>();
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_TOKEN, true));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_PRIVATE, true));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_LABEL, Settings.ApplicationName));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_ID, ckaId));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_SENSITIVE, true));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_DECRYPT, true));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_SIGN, true));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_SIGN_RECOVER, true));
privateKeyAttributes.Add(new ObjectAttribute(CKA.CKA_UNWRAP, true));
// Specify key generation mechanism
Mechanism mechanism = new Mechanism(CKM.CKM_RSA_PKCS_KEY_PAIR_GEN);
// Generate key pair
ObjectHandle publicKeyHandle = null;
ObjectHandle privateKeyHandle = null;
session.GenerateKeyPair(mechanism, publicKeyAttributes, privateKeyAttributes, out publicKeyHandle, out privateKeyHandle);
// Do something interesting with generated key pair
// Destroy keys
session.DestroyObject(privateKeyHandle);
session.DestroyObject(publicKeyHandle);
session.Logout();
}
}
}
public bool Run(object[] inputParams)
{
using (Pkcs11 pkcs11 = new Pkcs11(Settings.Pkcs11LibraryPath, false))
{
// Find first slot with token present
Slot slot = Helpers.GetUsableSlot(pkcs11);
// Open RW session
using (Session session = slot.OpenSession(false))
{
string pin = Convert.ToString(inputParams[0]);
Mechanism mechanism = null;
string opName = "sha256";
string pathSource = null;
if (inputParams.Length >= 2)
{
opName = Convert.ToString(inputParams[1]);
}
if (inputParams.Length >= 3)
{
pathSource = Convert.ToString(inputParams[2]);
}
if (opName.Equals("sha512"))
{
mechanism = new Mechanism(CKM.CKM_SHA512);
}
else if (opName.Equals("sha384"))
{
mechanism = new Mechanism(CKM.CKM_SHA384);
}
else
{
mechanism = new Mechanism(CKM.CKM_SHA256);
opName = "sha256";
}
Console.WriteLine("Mechanism is " + opName);
if (String.IsNullOrEmpty(pathSource))
{
pathSource = Settings.Pkcs11LibraryPath;
}
// Login as normal user
session.Login(CKU.CKU_USER, pin);
using (FileStream sourceFileStream = new FileStream(pathSource, FileMode.Open, FileAccess.Read))
{
byte[] digestBytes = session.Digest(mechanism, sourceFileStream);
Console.WriteLine("Digest Text: " + ConvertUtils.BytesToHexString(digestBytes));
}
session.Logout();
slot.CloseSession(session);
}
}
return(true);
}
private void SetupMechanisms()
{
mechanisms["AccInput"] = new Mechanism
{
name = "AccInput",
trialType = TrialType.AccInput,
rate = 0f,
trials = accTrials,
trialsLeft = accTrials,
behavior = UrnEntryBehavior.Persist
};
mechanisms["FabInput"] = new Mechanism
{
name = "FabInput",
trialType = TrialType.FabInput,
rate = 0f,
trials = fabTrials,
trialsLeft = fabTrials,
behavior = UrnEntryBehavior.Persist
};
mechanisms["RejInput"] = new Mechanism
{
name = "RejInput",
trialType = TrialType.RejInput,
rate = 0f,
trials = rejTrials,
trialsLeft = rejTrials,
behavior = UrnEntryBehavior.Override
};
mechanisms["AssistSuccess"] = new Mechanism
{
name = "AssistSuccess",
trialType = TrialType.AssistSuccess,
rate = 0f,
trials = assistSuccessTrials,
trialsLeft = assistSuccessTrials,
behavior = UrnEntryBehavior.Persist
};
mechanisms["AssistFail"] = new Mechanism
{
name = "AssistFail",
trialType = TrialType.AssistFail,
rate = 0f,
trials = assistFailTrials,
trialsLeft = assistFailTrials,
behavior = UrnEntryBehavior.Persist
};
mechanisms["ExplicitSham"] = new Mechanism
{
name = "ExplicitSham",
trialType = TrialType.ExplicitSham,
rate = 0f,
trials = explicitShamTrials,
trialsLeft = explicitShamTrials,
behavior = UrnEntryBehavior.Persist
};
}
//Method that sets robots position
public static void SetRobPos(int setVal)
{
Station station2 = Project.ActiveProject as Station;
Mechanism mech = station2.ActiveTask.Mechanism;
mech.SetJointValues(RecData.JointValuesList[setVal], false);
//AddMarkup();
}
public void Remove()
{
OnRemove();
TryRemoveNetwork(Mechanism.Body);
Mechanism = null !;
Removed = true;
}
public Army()
{
Soldier soldier = new Soldier("Fighter", 100, 10);
Rider rider = new Rider("Rider", 100, 10);
Mechanism mechanism = new Mechanism("catapult", 790, 100, 10, 50);
Console.WriteLine("Army is created!");
}
public void StartDraggingUnplaced(Mechanism mechanism)
{
draggingMechanism = mechanism;
if (draggingMechanism != null)
{
draggingMechanism.StartDrag();
}
}
private void Start()
{
mechanism = GetComponent <Mechanism>();
if (mechanism == null)
{
Debug.LogError("在" + gameObject.name + "中，找不到Machanism组件");
}
}
void StopDragging()
{
if (draggingMechanism != null)
{
draggingMechanism.StopDrag();
draggingMechanism = null;
}
}
/// <summary>
/// Generates a new CryptoKey object that represents a public/private key pair.
/// </summary>
/// <param name="session">The Cryptoki session context.</param>
/// <param name="mechanism">The key algorithm and parameters.</param>
/// <param name="publicKeyTemplate">The public key attribute template.</param>
/// <param name="privateKeyTemplate">The private key attribute template.</param>
/// <returns></returns>
public static CryptoKey GenerateKeyPair(Session session, Mechanism mechanism, CryptokiAttribute[] publicKeyTemplate, CryptokiAttribute[] privateKeyTemplate)
{
CryptoKey ret = GenerateKeyPairInternal(session, mechanism, publicKeyTemplate, privateKeyTemplate);
session.AddSessionObject(ret);
return(ret);
}
/// <summary>
/// Generates a new CryptoKey within the specified session context with the specified key mechanism and key template.
/// </summary>
/// <param name="session">The Cryptoki session context.</param>
/// <param name="mechanism">The key algorithm and parameters.</param>
/// <param name="template">The key attribute template that defines the resulting key's properties.</param>
/// <returns></returns>
public static CryptoKey GenerateKey(Session session, Mechanism mechanism, CryptokiAttribute[] template)
{
CryptoKey ret = GenerateKeyInternal(session, mechanism, template);
session.AddSessionObject(ret);
return(ret);
}
void Start()
{
parentMechanism = transform.GetComponentInParent <Mechanism>();
if (parentMechanism == null)
{
Debug.LogError("在" + gameObject.name + "中，找不到parentMechanism");
}
}
/// <summary>
/// Verifies that a digital signature is valid by determining the hash value in the signature using the specified hash algorithm and padding, and comparing it to the provided hash value
/// </summary>
/// <param name="hash">he hash value of the signed data</param>
/// <param name="signature">The signature data to be verified</param>
/// <param name="hashAlgorithm">The hash algorithm used to create the hash value</param>
/// <param name="padding">The padding mode</param>
/// <returns>True if the signature is valid, false otherwise</returns>
public override bool VerifyHash(byte[] hash, byte[] signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
{
if (hash == null || hash.Length == 0)
{
throw new ArgumentNullException(nameof(hash));
}
if (signature == null || signature.Length == 0)
{
throw new ArgumentNullException(nameof(signature));
}
if (hashAlgorithm == null)
{
throw new ArgumentNullException(nameof(hashAlgorithm));
}
if (padding == null)
{
throw new ArgumentNullException(nameof(padding));
}
if (padding == RSASignaturePadding.Pkcs1)
{
byte[] pkcs1DigestInfo = CreatePkcs1DigestInfo(hash, hashAlgorithm);
if (pkcs1DigestInfo == null)
{
throw new NotSupportedException(string.Format("Algorithm {0} is not supported", hashAlgorithm));
}
using (Session session = _certContext.TokenContext.SlotContext.Slot.OpenSession(SessionType.ReadOnly))
using (var mechanism = new Mechanism(CKM.CKM_RSA_PKCS))
{
session.Verify(mechanism, _certContext.PubKeyHandle, pkcs1DigestInfo, signature, out bool isValid);
return(isValid);
}
}
else if (padding == RSASignaturePadding.Pss)
{
CkRsaPkcsPssParams pssMechanismParams = CreateCkRsaPkcsPssParams(hash, hashAlgorithm);
if (pssMechanismParams == null)
{
throw new NotSupportedException(string.Format("Algorithm {0} is not supported", hashAlgorithm.Name));
}
using (Session session = _certContext.TokenContext.SlotContext.Slot.OpenSession(SessionType.ReadOnly))
using (var mechanism = new Mechanism(CKM.CKM_RSA_PKCS_PSS, pssMechanismParams))
{
session.Verify(mechanism, _certContext.PubKeyHandle, hash, signature, out bool isValid);
return(isValid);
}
}
else
{
throw new NotSupportedException(string.Format("Padding {0} is not supported", padding));
}
}
public void _01_BasicSignEncryptAndDecryptVerifyTest()
{
Helpers.CheckPlatform();
using (Pkcs11 pkcs11 = new Pkcs11(Settings.Pkcs11LibraryPath, Settings.AppType))
{
// Find first slot with token present
Slot slot = Helpers.GetUsableSlot(pkcs11);
// Open RW session
using (Session session = slot.OpenSession(SessionType.ReadWrite))
{
// Login as normal user
session.Login(CKU.CKU_USER, Settings.NormalUserPin);
// Generate asymetric key pair
ObjectHandle publicKey = null;
ObjectHandle privateKey = null;
Helpers.GenerateKeyPair(session, out publicKey, out privateKey);
// Specify signing mechanism
Mechanism signingMechanism = new Mechanism(CKM.CKM_SHA1_RSA_PKCS);
// Generate symetric key
ObjectHandle secretKey = Helpers.GenerateKey(session);
// Generate random initialization vector
byte[] iv = session.GenerateRandom(8);
// Specify encryption mechanism with initialization vector as parameter
Mechanism encryptionMechanism = new Mechanism(CKM.CKM_DES3_CBC, iv);
byte[] sourceData = ConvertUtils.Utf8StringToBytes("Passw0rd");
// Sign and encrypt data
byte[] signature = null;
byte[] encryptedData = null;
session.SignEncrypt(signingMechanism, privateKey, encryptionMechanism, secretKey, sourceData, out signature, out encryptedData);
// Do something interesting with signature and encrypted data
// Decrypt data and verify signature of data
byte[] decryptedData = null;
bool isValid = false;
session.DecryptVerify(signingMechanism, publicKey, encryptionMechanism, secretKey, encryptedData, signature, out decryptedData, out isValid);
// Do something interesting with decrypted data and verification result
Assert.IsTrue(ConvertUtils.BytesToBase64String(sourceData) == ConvertUtils.BytesToBase64String(decryptedData));
Assert.IsTrue(isValid);
session.DestroyObject(privateKey);
session.DestroyObject(publicKey);
session.DestroyObject(secretKey);
session.Logout();
}
}
}
public void _02_SignAndVerifyMultiPartTest()
{
if (Platform.UnmanagedLongSize != 4 || Platform.StructPackingSize != 1)
{
Assert.Inconclusive("Test cannot be executed on this platform");
}
using (Pkcs11 pkcs11 = new Pkcs11(Settings.Pkcs11LibraryPath, Settings.UseOsLocking))
{
// Find first slot with token present
Slot slot = Helpers.GetUsableSlot(pkcs11);
// Open RW session
using (Session session = slot.OpenSession(false))
{
// Login as normal user
session.Login(CKU.CKU_USER, Settings.NormalUserPin);
// Generate key pair
ObjectHandle publicKey = null;
ObjectHandle privateKey = null;
Helpers.GenerateKeyPair(session, out publicKey, out privateKey);
// Specify signing mechanism
Mechanism mechanism = new Mechanism(CKM.CKM_SHA1_RSA_PKCS);
byte[] sourceData = ConvertUtils.Utf8StringToBytes("Hello world");
byte[] signature = null;
bool isValid = false;
// Multipart signing can be used i.e. for signing of streamed data
using (MemoryStream inputStream = new MemoryStream(sourceData))
{
// Sign data
// Note that in real world application we would rather use bigger read buffer i.e. 4096
signature = session.Sign(mechanism, privateKey, inputStream, 8);
}
// Do something interesting with signature
// Multipart verification can be used i.e. for signature verification of streamed data
using (MemoryStream inputStream = new MemoryStream(sourceData))
{
// Verify signature
// Note that in real world application we would rather use bigger read buffer i.e. 4096
session.Verify(mechanism, publicKey, inputStream, signature, out isValid, 8);
}
// Do something interesting with verification result
Assert.IsTrue(isValid);
session.DestroyObject(privateKey);
session.DestroyObject(publicKey);
session.Logout();
}
}
}
internal IReactionSet Initiate(IChemObjectSet <IAtomContainer> reactants, IChemObjectSet <IAtomContainer> agents, bool isReverse, CheckReactantAtom checkReactantAtom, CheckAtom checkAtom, CheckBond checkBond)
{
CheckInitiateParams(reactants, agents);
IReactionSet setOfReactions = reactants.Builder.NewReactionSet();
IAtomContainer reactant = reactants[0];
// if the parameter hasActiveCenter is not fixed yet, set the active centers
IParameterReaction ipr = base.GetParameterClass(typeof(SetReactionCenter));
if (ipr != null && !ipr.IsSetParameter)
{
SetActiveCenters(reactant, checkReactantAtom, checkAtom, checkBond);
}
foreach (var atomi in reactant.Atoms)
{
if (atomi.IsReactiveCenter && checkReactantAtom(reactant, atomi))
{
foreach (var bondi in reactant.GetConnectedBonds(atomi))
{
if (bondi.IsReactiveCenter && checkBond(bondi))
{
IAtom atomj = bondi.GetOther(atomi);
if (atomj.IsReactiveCenter && checkAtom(atomj) && !reactant.GetConnectedSingleElectrons(atomj).Any())
{
IAtom[] atomList;
if (isReverse)
{
atomList = new[] { atomj, atomi }
}
;
else
{
atomList = new[] { atomi, atomj }
};
var bondList = new[] { bondi };
IChemObjectSet <IAtomContainer> moleculeSet = reactant.Builder.NewChemObjectSet <IAtomContainer>();
moleculeSet.Add(reactant);
IReaction reaction = Mechanism.Initiate(moleculeSet, atomList, bondList);
if (reaction == null)
{
continue;
}
else
{
setOfReactions.Add(reaction);
}
}
}
}
}
}
return(setOfReactions);
}
/// <summary>
/// Initialize the processor
/// </summary>
/// <returns>An auth tag to start the authentication process</returns>
public override Tag Initialize(string id, string password)
{
base.Initialize(id, password);
var tag = TagRegistry.GetTag <Auth>("auth", Namespaces.Sasl);
tag.Mechanism = Mechanism.GetMechanism(MechanismType.DigestMd5);
return(tag);
}
public void _01_BasicWrapAndUnwrapKeyTest()
{
if (Platform.UnmanagedLongSize != 4 || Platform.StructPackingSize != 0)
{
Assert.Inconclusive("Test cannot be executed on this platform");
}
using (Pkcs11 pkcs11 = new Pkcs11(Settings.Pkcs11LibraryPath, Settings.AppType))
{
// Find first slot with token present
Slot slot = Helpers.GetUsableSlot(pkcs11);
// Open RW session
using (Session session = slot.OpenSession(SessionType.ReadWrite))
{
// Login as normal user
session.Login(CKU.CKU_USER, Settings.NormalUserPin);
// Generate asymetric key pair
ObjectHandle publicKey = null;
ObjectHandle privateKey = null;
Helpers.GenerateKeyPair(session, out publicKey, out privateKey);
// Generate symetric key
ObjectHandle secretKey = Helpers.GenerateKey(session);
// Specify wrapping mechanism
Mechanism mechanism = new Mechanism(CKM.CKM_RSA_PKCS);
// Wrap key
byte[] wrappedKey = session.WrapKey(mechanism, publicKey, secretKey);
// Do something interesting with wrapped key
Assert.IsNotNull(wrappedKey);
// Define attributes for unwrapped key
List <ObjectAttribute> objectAttributes = new List <ObjectAttribute>();
objectAttributes.Add(new ObjectAttribute(CKA.CKA_CLASS, CKO.CKO_SECRET_KEY));
objectAttributes.Add(new ObjectAttribute(CKA.CKA_KEY_TYPE, CKK.CKK_DES3));
objectAttributes.Add(new ObjectAttribute(CKA.CKA_ENCRYPT, true));
objectAttributes.Add(new ObjectAttribute(CKA.CKA_DECRYPT, true));
objectAttributes.Add(new ObjectAttribute(CKA.CKA_DERIVE, true));
objectAttributes.Add(new ObjectAttribute(CKA.CKA_EXTRACTABLE, true));
// Unwrap key
ObjectHandle unwrappedKey = session.UnwrapKey(mechanism, privateKey, wrappedKey, objectAttributes);
// Do something interesting with unwrapped key
Assert.IsTrue(unwrappedKey.ObjectId != CK.CK_INVALID_HANDLE);
session.DestroyObject(privateKey);
session.DestroyObject(publicKey);
session.DestroyObject(secretKey);
session.Logout();
}
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public override Tag Initialize()
{
base.Initialize();
var tag = TagRegistry.GetTag <Auth>("auth", Namespaces.SASL);
tag.Mechanism = Mechanism.GetMechanism(MechanismType.DigestMD5);
return(tag);
}
static void Main(string[] args)
{
try
{
// Инициализировать библиотеку
Console.WriteLine("Library initialization");
using (var pkcs11 = new Pkcs11(Settings.RutokenEcpDllDefaultPath, Settings.OsLockingDefault))
{
// Получить доступный слот
Console.WriteLine("Checking tokens available");
Slot slot = Helpers.GetUsableSlot(pkcs11);
// Определение поддерживаемых токеном механизмов
Console.WriteLine("Checking mechanisms available");
List <CKM> mechanisms = slot.GetMechanismList();
Errors.Check(" No mechanisms available", mechanisms.Count > 0);
bool isGost28147_89Supported = mechanisms.Contains((CKM)Extended_CKM.CKM_GOST28147_KEY_GEN);
Errors.Check(" CKM_GOST28147_KEY_GEN isn`t supported!", isGost28147_89Supported);
// Открыть RW сессию в первом доступном слоте
Console.WriteLine("Opening RW session");
using (Session session = slot.OpenSession(false))
{
// Выполнить аутентификацию Пользователя
Console.WriteLine("User authentication");
session.Login(CKU.CKU_USER, SampleConstants.NormalUserPin);
try
{
// Определить механизм генерации ключа
Console.WriteLine("Generating GOST 28147-89 secret key...");
var mechanism = new Mechanism((uint)Extended_CKM.CKM_GOST28147_KEY_GEN);
// Сгенерировать секретный ключ ГОСТ 28147-89
ObjectHandle symmetricKey = session.GenerateKey(mechanism, SymmetricKeyAttributes);
Errors.Check("Invalid key handle", symmetricKey.ObjectId != CK.CK_INVALID_HANDLE);
Console.WriteLine("Generating has been completed successfully");
}
finally
{
// Сбросить права доступа как в случае исключения,
// так и в случае успеха.
// Сессия закрывается автоматически.
session.Logout();
}
}
}
}
catch (Pkcs11Exception ex)
{
Console.WriteLine($"Operation failed [Method: {ex.Method}, RV: {ex.RV}]");
}
catch (Exception ex)
{
Console.WriteLine($"Operation failed [Message: {ex.Message}]");
}
}
/// <summary>
/// Derives a CryptoKey object with the specified key algorithm and key attribute template
/// </summary>
/// <param name="mechanism">The Cryptoki session context.</param>
/// <param name="template">The key attribute template.</param>
/// <returns></returns>
public CryptoKey DeriveKey(Mechanism mechanism, CryptokiAttribute[] template)
{
if (m_isDisposed) throw new ObjectDisposedException();
CryptoKey ret = DeriveKeyInternal(mechanism, template);
m_session.AddSessionObject(ret);
return ret;
}
public Level(int levelID, string name, string difficulty, Color32 backgroundColor, char[,] groundLayout, Entity[,] entityLayout, Mechanism[,] mechanismLayout)
{
_levelID = levelID;
_name = name;
_difficulty = difficulty;
_backgroundColor = backgroundColor;
_groundLayout = groundLayout;
_entityLayout = entityLayout;
_mechanismLayout = mechanismLayout;
}
public static byte[] DeriveSecret(EcIdentifier ecIdentifier, EcKeyPair publicKeyPair, string password)
{
using (Pkcs11 pk = new Pkcs11(LibraryPath, false))
{
var slot = pk.GetSlotList(false)
.First(s =>
{
try
{
bool found;
using (Session session = s.OpenSession(true))
{
found = s.GetTokenInfo().SerialNumber == ecIdentifier.TokenSerialNumber;
}
return(found);
}
catch
{
return(false);
}
});
using (Session session = slot.OpenSession(false))
{
session.Login(CKU.CKU_USER, password);
var objectPrivate = GetObjectHandle(ecIdentifier.KeyLabel, session, CKO.CKO_PRIVATE_KEY);
var publicKey = publicKeyPair.ToDre();
byte[] data = session.GenerateRandom(32);
var mechanism = new Mechanism(CKM.CKM_ECDH1_DERIVE, new CkEcdh1DeriveParams(0, null, publicKey));
var deriveAttributes = new List <ObjectAttribute>
{
new ObjectAttribute(CKA.CKA_TOKEN, false),
new ObjectAttribute(CKA.CKA_CLASS, CKO.CKO_SECRET_KEY),
new ObjectAttribute(CKA.CKA_KEY_TYPE, CKK.CKK_GENERIC_SECRET),
new ObjectAttribute(CKA.CKA_SENSITIVE, false),
new ObjectAttribute(CKA.CKA_EXTRACTABLE, true),
new ObjectAttribute(CKA.CKA_ENCRYPT, true),
new ObjectAttribute(CKA.CKA_DECRYPT, true),
new ObjectAttribute(CKA.CKA_WRAP, true),
new ObjectAttribute(CKA.CKA_UNWRAP, true),
new ObjectAttribute(CKA.CKA_VALUE_LEN, 320 / 8),
};
var derivedKey = session.DeriveKey(mechanism, objectPrivate, deriveAttributes);
var derivedSecret = GetDataFromObject(derivedKey, session, CKA.CKA_VALUE);
return(SHA512.Create().ComputeHash(derivedSecret));
}
}
}
void Breakage()
{
int randomNum;
randomNum = Random.Range(0, mechanisms.Length);
brokenMech = mechanisms[randomNum];
if (brokenMech.isBroken)
Breakage();
if (!brokenMech.isBroken)
{
brokenMech.BreakMechanism();
breakageText.text = "The " + mechanisms[randomNum].deviceName + " has broken!";
breakageText.enabled = true;
brokenMech.icon.SetTarget(brokenMech.gameObject);
currentBreaks++;
}
}
public void _01_DisposeMechanismTest()
{
byte[] parameter = new byte[8];
System.Random rng = new Random();
rng.NextBytes(parameter);
// Unmanaged memory for mechanism parameter stored in low level CK_MECHANISM struct
// is allocated by constructor of Mechanism class.
Mechanism mechanism1 = new Mechanism(CKM.CKM_DES_CBC, parameter);
// Do something interesting with mechanism
// This unmanaged memory is freed by Dispose() method.
mechanism1.Dispose();
// Mechanism class can be used in using statement which defines a scope
// at the end of which an object will be disposed (and unmanaged memory freed).
using (Mechanism mechanism2 = new Mechanism(CKM.CKM_DES_CBC, parameter))
{
// Do something interesting with mechanism
}
#pragma warning disable 0219
// Explicit calling of Dispose() method can also be ommitted
// and this is the prefered way how to use Mechanism class.
Mechanism mechanism3 = new Mechanism(CKM.CKM_DES_CBC, parameter);
// Do something interesting with mechanism
// Dispose() method will be called (and unmanaged memory freed) by GC eventually
// but we cannot be sure when will this occur.
#pragma warning restore 0219
}
/// <summary>
/// Creates and Resets a new timer in Time TimeMode.
/// </summary>
/// <param name="mechanism">The directional mechanism to use.</param>
public UTimer(Mechanism mechanism)
: this(mechanism, TimeMode.Time)
{
}
//Load Level from JSON
public static Level LoadFromJSON(Dictionary<string, object> levelData, int index, bool calledFromEditor)
{
#region Throw Exceptions If JSON Data Does Not Contain All Neccessary Fields
if(!levelData.ContainsKey("id"))
throw new Exception("ID not present in level file!");
if(!levelData.ContainsKey("name"))
throw new Exception("Name not present in level file!");
if(!levelData.ContainsKey("difficulty"))
throw new Exception("Difficulty not present in level file!");
if(!levelData.ContainsKey("creator"))
throw new Exception("creator not present in level file!");
if(!levelData.ContainsKey("colour"))
throw new Exception("Colour not present in level file!");
if(!levelData.ContainsKey("dimensions"))
throw new Exception("Dimensions not present in level file!");
if(!levelData.ContainsKey("groundlayer"))
throw new Exception("Ground layout not present in level file!");
if(!levelData.ContainsKey("entitylayer"))
throw new Exception("Entity layout not present in level file!");
if(!levelData.ContainsKey("mechanismlayer"))
throw new Exception("Mechanism layout not present in level file!");
if(!levelData.ContainsKey("mechanisms"))
throw new Exception("Mechanism data not present in level file!");
#endregion
string name = (string)levelData["name"];
string difficulty = (string)levelData["difficulty"];
int levelWidth = int.Parse(((string)levelData["dimensions"]).Substring(0,2));
int levelHeight = int.Parse(((string)levelData["dimensions"]).Substring(2,2));
Color backgroundColor = (Color)new Color32(byte.Parse(((string)levelData["colour"]).Substring(0,3)), byte.Parse(((string)levelData["colour"]).Substring(3,3)), byte.Parse(((string)levelData["colour"]).Substring(6,3)), 1);
string rawGroundLayer = Crypto.Decompress((string)levelData["groundlayer"]);
string rawEntityLayer = Crypto.Decompress((string)levelData["entitylayer"]);
string rawMechanismLayer = Crypto.Decompress((string)levelData["mechanismlayer"]);
string rawMechanismData = (string)levelData["mechanisms"];
char[,] groundLayer = new char[levelWidth, levelHeight];
char[,] entityLayer = new char[levelWidth, levelHeight];
char[,] mechanismLayer = new char[levelWidth, levelHeight];
Entity[,] entities = new Entity[levelWidth, levelHeight];
Mechanism[,] mechanisms = new Mechanism[levelWidth, levelHeight];
int[] mechanismInputs = new int[3]{0,0,0};
int mechanismCount = 0;
GameObject currentObject;
int filePlayerCount = 0;
#region More Exceptions For Level Data That Has Been Corrupted/Tampered With
for(int x = 0; x < (levelWidth * levelHeight); x++)
{
if(rawEntityLayer[x] == 'P')
filePlayerCount++;
}
//Allow players to load unfinished levels into the editor
if (!calledFromEditor)
{
if (!rawGroundLayer.Contains("X"))
throw new Exception("There Must Be Atleast One Finish Block");
if (filePlayerCount != 1)
throw new Exception("Invalid Player Object Count");
}
if(((string)levelData["colour"]).Length != 9)
throw new Exception("Invalid Background Colour");
if (rawMechanismData.Length != rawMechanismLayer.Replace("Z", "").Length * 2)
throw new Exception("Invalid Mechanism Data");
if(rawGroundLayer.Length != levelHeight * levelWidth || rawEntityLayer.Length != levelHeight * levelWidth || rawMechanismLayer.Length != levelHeight * levelWidth)
throw new Exception("Invalid Block Count");
#endregion
//Change the background color instantly if loading into level edior, or tween it if not
if (Application.loadedLevel == 3)
Camera.main.backgroundColor = backgroundColor;
else
Camera.main.GetComponent<CameraControl>().ChangeBackgroundColour(backgroundColor);
for(int y = 0; y < levelHeight; y++)
{
for(int x = 0; x < levelWidth; x++)
{
groundLayer[x,y] = rawGroundLayer[x + (levelWidth * y)];
if(groundLayer[x,y] != 'Z')
{
currentObject = Instantiate(GameData.GroundTypes[groundLayer[x,y]], new Vector3(x*2, index == -1? -1 : -2, y*2), Quaternion.identity) as GameObject;
currentObject.transform.parent = GameObject.Find("Level Objects").transform;
currentObject.name = 'G' + x.ToString("00") + y.ToString("00");
currentObject.GetComponent<Block>().Spawn(x, groundLayer[x, y]);
}
entityLayer[x,y] = rawEntityLayer[x + (levelWidth * y)];
if(entityLayer[x,y] != 'Z')
{
if(entityLayer[x,y] != 'P' || Application.loadedLevel == 2)
{
currentObject = Instantiate(GameData.EntityTypes[entityLayer[x,y]], new Vector3(x*2, (index == -1)? 1 : 0, y*2), Quaternion.identity) as GameObject;
currentObject.transform.parent = GameObject.Find("Level Objects").transform;
currentObject.name = 'E' + x.ToString("00") + y.ToString("00");
currentObject.GetComponent<Block>().Spawn(x, entityLayer[x, y]);
}
else
{
currentObject = GameObject.Find("Player");
currentObject.transform.position = new Vector3(x*2, (index == -1)? 1 : 0, y*2);
}
currentObject.GetComponent<Entity>().SetDimensions((byte)x, (byte)y);
entities[x,y] = currentObject.GetComponent<Entity>();
if(groundLayer[x,y] == 'P' || groundLayer[x,y] == 'Z')
throw new Exception("Entities Cannot Spawn Over Nothing");
if(groundLayer[x,y] == 'X')
throw new Exception("Entities Cannot Spawn Over A Finish Block");
}
mechanismLayer[x,y] = rawMechanismLayer[x + (levelWidth * y)];
if(mechanismLayer[x,y] != 'Z')
{
currentObject = Instantiate(GameData.MechanismTypes[mechanismLayer[x,y]], new Vector3(x*2, (index == -1)? 1 : 0, y*2), Quaternion.Euler(new Vector3(-90,0,0))) as GameObject;
currentObject.transform.parent = GameObject.Find("Level Objects").transform;
currentObject.name = 'M' + x.ToString("00") + y.ToString("00");
currentObject.GetComponent<Block>().Spawn(x, mechanismLayer[x, y]);
mechanisms[x,y] = currentObject.GetComponent<Mechanism>();
//Setup mechanism data from level file
currentObject.GetComponent<Mechanism>().group = byte.Parse(rawMechanismData[mechanismCount * 2].ToString());
if(currentObject.GetComponent<Mechanism>().receivesInput)
currentObject.GetComponent<Mechanism>().startOpen = (byte.Parse(rawMechanismData[(mechanismCount * 2) + 1].ToString()) == 0? false : true);
currentObject.GetComponent<Renderer>().material.mainTexture = Resources.Load("Textures\\" + GameData.MechanismTypes[mechanismLayer[x, y]].name + currentObject.GetComponent<Mechanism>().group.ToString()) as Texture;
for (int g = 0; g < 3; g++)
{
if(!mechanisms[x,y].receivesInput && mechanisms[x,y].group == g)
mechanismInputs[g] += 1;
}
if(groundLayer[x,y] == 'P' || groundLayer[x,y] == 'Z')
throw new Exception("Mechanisms Cannot Spawn Over Nothing");
if(groundLayer[x,y] == 'X')
throw new Exception("Mechanisms Cannot Spawn On A Finish Block");
if(!mechanisms[x,y].receivesInput && entityLayer[x,y] != 'Z')
throw new Exception("Input mechanisms cannot spawn on entities");
if(mechanisms[x,y].receivesInput && entityLayer[x,y] != 'Z' && !entities[x,y].moveable)
throw new Exception("Only moveable entities can spawn inside mechanisms that receive input");
mechanismCount++;
}
}
}
foreach(Mechanism m in mechanisms)
{
if(m != null && m.receivesInput)
m.inputRequired = mechanismInputs[m.group];
}
return new Level(index, name, difficulty, backgroundColor, groundLayer, entities, mechanisms);
}
public void HasBeenFixed()
{
breakageText.enabled = false;
brokenMech = null;
currentBreaks--;
}
void Update () {
if (!selectionPanel.activeSelf)
return;
if(tooltipPanel.activeSelf)
tooltipPanel.GetComponent<RectTransform>().anchoredPosition = new Vector2(Input.mousePosition.x + (GameObject.Find("Tooltip Panel").GetComponent<RectTransform>().rect.width / 2), Input.mousePosition.y - Screen.height - (GameObject.Find("Tooltip Panel").GetComponent<RectTransform>().rect.height / 2));
if (levelComplete && levelChanged)
levelComplete = false;
if(Input.GetKeyDown(KeyCode.U))
StartCoroutine(GetUserFromSession());
//Reset Selected arrow each frame
if(currentArrow)
currentArrow.GetComponent<Renderer>().material.color = Color.white;
#region Allow User To Clear Entire Level
//if(Input.GetKeyDown(KeyCode.Backspace))
//{
// ClearLevel();
//}
#endregion
Ray mouseRay = Camera.main.ScreenPointToRay (Input.mousePosition);
//Destroy the cursor this frame if one is present, so the next can be spawned
if (cursor)
Destroy(cursor);
//Check if mouse is being hovered over valid level space and allow to user to create or destroy aspects of the level
if (ground.Raycast(mouseRay, out hitDist) && ValidMousePos() && !helpEnabled)
{
#region Create Appropriate Cursor If Mouse Is Within Bounds Of Level
mouseVector = mouseRay.GetPoint(hitDist);
mouseVector = new Vector3(Mathf.Round(mouseRay.GetPoint(hitDist).x / 2) * 2,0,Mathf.Round(mouseRay.GetPoint(hitDist).z / 2) * 2);
if((int)(mouseVector.x / 2) >= 0 && (int)(mouseVector.z / 2) >= 0 && (int)(mouseVector.x / 2) < currentWidth && (int)(mouseVector.z / 2) < currentLength)
{
cursorOOB = false;
if(selectedLayer == 'G' && groundLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] == null ||
selectedLayer == 'E' && entityLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] == null && groundLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] != null && groundLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] != 'P' && mechanismLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] == null && groundLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] != 'X' ||
selectedLayer == 'M' && selectedBlock != 'T' && mechanismLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] == null && groundLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] != null && groundLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] != 'P' && entityLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] == null && groundLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] != 'X' ||
selectedLayer == 'M' && selectedBlock == 'T' && mechanismLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] != null)
{
validChoice = true;
}
else
{
validChoice = false;
}
}
else
{
cursorOOB = true;
}
if(!cursorOOB)
{
if(validChoice)
{
cursor = Instantiate(Resources.Load("ValidChoice"), (selectedLayer == 'G') ? mouseVector - new Vector3(0,1,0) : mouseVector + new Vector3(0,1,0), Quaternion.identity) as GameObject;
}
else
{
cursor = Instantiate(Resources.Load("InvalidChoice"), (selectedLayer == 'G') ? mouseVector - new Vector3(0,1,0) : mouseVector + new Vector3(0,1,0), Quaternion.identity) as GameObject;
}
}
#endregion
#region Instantiate Or Destroy A Level Object Based On Users Input
if(Input.GetMouseButton(0) && validChoice && !cursorOOB)
{
if(selectedLayer == 'G')
{
currentObject = Instantiate(GameData.GroundTypes[selectedBlock], mouseVector - new Vector3(0, 1, 0), Quaternion.identity) as GameObject;
groundLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] = selectedBlock;
levelChanged = true;
}
else if(selectedLayer == 'E')
{
currentObject = Instantiate(GameData.EntityTypes[selectedBlock], mouseVector + new Vector3(0, 1, 0), Quaternion.identity) as GameObject;
entityLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] = selectedBlock;
levelChanged = true;
if (selectedBlock == 'P')
{
if(playerX != -1)
StartCoroutine(DeleteBlock('E', playerX, playerY));
playerX = (int)(mouseVector.x / 2);
playerY = (int)(mouseVector.z / 2);
}
}
else if(selectedLayer == 'M')
{
//If tinker is not selected, spawn in selected mechanism as usual
if (selectedBlock != 'T')
{
currentObject = Instantiate(GameData.MechanismTypes[selectedBlock], mouseVector + new Vector3(0, 1, 0), Quaternion.Euler(new Vector3(-90, 0, 0))) as GameObject;
mechanismLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] = selectedBlock;
mechanisms[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] = currentObject.GetComponent<Mechanism>();
levelChanged = true;
}
else
{
Destroy(selectedMechObject);
selectedMechObject = Instantiate(Resources.Load("SelectedMechanism"), mouseVector + new Vector3(0, 1, 0), Quaternion.Euler(new Vector3(-90, 0, 0))) as GameObject;
selectedMechanism = mechanisms[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)];
OpenTinker();
}
}
if (!(selectedLayer == 'M' && selectedBlock == 'T'))
{
currentObject.transform.parent = levelObjects.transform;
currentObject.name = selectedLayer + ((int)(mouseVector.x / 2)).ToString("00") + ((int)(mouseVector.z / 2)).ToString("00");
currentObject.GetComponent<Block>().Spawn(0, selectedBlock);
}
}
else if(Input.GetMouseButton(1) && !validChoice && !cursorOOB)
{
//Stop the user from deleting ground if there is another object resting on it
if(selectedLayer == 'G' && (entityLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] != null || mechanismLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] != null))
return;
//Stop the user from deleting mechanisms if they have selected an entity
if(selectedLayer == 'E' && mechanismLayout[(int)(mouseVector.x / 2),(int)(mouseVector.z / 2)] != null)
return;
//Stop the user from deleting entities if they have selected a mechanism
if (selectedLayer == 'M' && entityLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] != null)
return;
//If deleting a player entity, reset the player position variable
if (selectedLayer == 'E' && entityLayout[(int)(mouseVector.x / 2), (int)(mouseVector.z / 2)] == 'P')
playerX = -1;
StartCoroutine(DeleteBlock(selectedLayer, (int)(mouseVector.x / 2), (int)(mouseVector.z / 2)));
}
#endregion
}
#region Level Size Control Via Arrows
//Check if user is hovering cursor over the resizable level arrows
if(Physics.Raycast(mouseRay, out hit) && hit.collider.gameObject.tag == "EditorArrow" && ValidMousePos())
{
currentArrow = hit.collider.gameObject;
currentArrow.GetComponent<Renderer>().material.color = Color.yellow;
//Resize level depending on which arrow clicked
if(Input.GetMouseButtonDown(0))
{
int sizeModifier = (currentArrow.name.Contains("Increase")) ? 1 : -1;
if(currentArrow.transform.parent.gameObject == lengthArrows && (sizeModifier == 1 && currentLength < 29 || sizeModifier == -1 && currentLength > 4))
{
currentLength += sizeModifier;
iTween.MoveTo(lengthArrows, iTween.Hash("position", new Vector3(currentWidth - 3,0,(currentLength * 2) + 1), "time", .5f));
iTween.MoveTo(widthArrows, iTween.Hash("position", new Vector3((currentWidth * 2) + 1,0,currentLength + 1), "time", .5f));
Camera.main.GetComponent<Grid>().ChangeGridSize(false, sizeModifier * 2);
if(sizeModifier == -1)
ClearLine(true, currentLength, currentWidth);
Camera.main.GetComponent<CameraControl>().ChangePivotPoint(new Vector3(0,0, sizeModifier));
CheckArrows();
}
else if(currentArrow.transform.parent.gameObject == widthArrows && (sizeModifier == 1 && currentWidth < 29 || sizeModifier == -1 && currentWidth > 4))
{
currentWidth += sizeModifier;
iTween.MoveTo(lengthArrows, iTween.Hash("position", new Vector3(currentWidth - 3,0,(currentLength * 2) + 1), "time", .5f));
iTween.MoveTo(widthArrows, iTween.Hash("position", new Vector3((currentWidth * 2) + 1,0,currentLength + 1), "time", .5f));
Camera.main.GetComponent<Grid>().ChangeGridSize(true, sizeModifier * 2);
if(sizeModifier == -1)
ClearLine(false, currentWidth, currentLength);
Camera.main.GetComponent<CameraControl>().ChangePivotPoint(new Vector3(sizeModifier,0, 0));
CheckArrows();
}
levelChanged = true;
}
}
#endregion
}
public void _03_ByteArrayParameterTest()
{
byte[] parameter = new byte[16];
System.Random rng = new Random();
rng.NextBytes(parameter);
// Create mechanism with the byte array parameter
Mechanism mechanism = new Mechanism(CKM.CKM_AES_CBC, parameter);
Assert.IsTrue(mechanism.Type == (ulong)CKM.CKM_AES_CBC);
// We access private members here just for the testing purposes
if (Platform.UnmanagedLongSize == 4)
{
if (Platform.StructPackingSize == 0)
{
HLA40.Mechanism mechanism40 = (HLA40.Mechanism)typeof(Mechanism).GetField("_mechanism40", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA40.CK_MECHANISM ckMechanism40 = (LLA40.CK_MECHANISM)typeof(HLA40.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism40);
Assert.IsTrue(ckMechanism40.Mechanism == (uint)CKM.CKM_AES_CBC);
Assert.IsTrue(ckMechanism40.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism40.ParameterLen) == parameter.Length);
}
else
{
HLA41.Mechanism mechanism41 = (HLA41.Mechanism)typeof(Mechanism).GetField("_mechanism41", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA41.CK_MECHANISM ckMechanism41 = (LLA41.CK_MECHANISM)typeof(HLA41.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism41);
Assert.IsTrue(ckMechanism41.Mechanism == (uint)CKM.CKM_AES_CBC);
Assert.IsTrue(ckMechanism41.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism41.ParameterLen) == parameter.Length);
}
}
else
{
if (Platform.StructPackingSize == 0)
{
HLA80.Mechanism mechanism80 = (HLA80.Mechanism)typeof(Mechanism).GetField("_mechanism80", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA80.CK_MECHANISM ckMechanism80 = (LLA80.CK_MECHANISM)typeof(HLA80.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism80);
Assert.IsTrue(ckMechanism80.Mechanism == (ulong)CKM.CKM_AES_CBC);
Assert.IsTrue(ckMechanism80.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism80.ParameterLen) == parameter.Length);
}
else
{
HLA81.Mechanism mechanism81 = (HLA81.Mechanism)typeof(Mechanism).GetField("_mechanism81", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA81.CK_MECHANISM ckMechanism81 = (LLA81.CK_MECHANISM)typeof(HLA81.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism81);
Assert.IsTrue(ckMechanism81.Mechanism == (ulong)CKM.CKM_AES_CBC);
Assert.IsTrue(ckMechanism81.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism81.ParameterLen) == parameter.Length);
}
}
parameter = null;
// Create mechanism with null byte array parameter
mechanism = new Mechanism(CKM.CKM_AES_CBC, parameter);
Assert.IsTrue(mechanism.Type == (ulong)CKM.CKM_AES_CBC);
// We access private members here just for the testing purposes
if (Platform.UnmanagedLongSize == 4)
{
if (Platform.StructPackingSize == 0)
{
HLA40.Mechanism mechanism40 = (HLA40.Mechanism)typeof(Mechanism).GetField("_mechanism40", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA40.CK_MECHANISM ckMechanism40 = (LLA40.CK_MECHANISM)typeof(HLA40.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism40);
Assert.IsTrue(ckMechanism40.Mechanism == (uint)CKM.CKM_AES_CBC);
Assert.IsTrue(ckMechanism40.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism40.ParameterLen == 0);
}
else
{
HLA41.Mechanism mechanism41 = (HLA41.Mechanism)typeof(Mechanism).GetField("_mechanism41", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA41.CK_MECHANISM ckMechanism41 = (LLA41.CK_MECHANISM)typeof(HLA41.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism41);
Assert.IsTrue(ckMechanism41.Mechanism == (uint)CKM.CKM_AES_CBC);
Assert.IsTrue(ckMechanism41.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism41.ParameterLen == 0);
}
}
else
{
if (Platform.StructPackingSize == 0)
{
HLA80.Mechanism mechanism80 = (HLA80.Mechanism)typeof(Mechanism).GetField("_mechanism80", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA80.CK_MECHANISM ckMechanism80 = (LLA80.CK_MECHANISM)typeof(HLA80.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism80);
Assert.IsTrue(ckMechanism80.Mechanism == (ulong)CKM.CKM_AES_CBC);
Assert.IsTrue(ckMechanism80.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism80.ParameterLen == 0);
}
else
{
HLA81.Mechanism mechanism81 = (HLA81.Mechanism)typeof(Mechanism).GetField("_mechanism81", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA81.CK_MECHANISM ckMechanism81 = (LLA81.CK_MECHANISM)typeof(HLA81.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism81);
Assert.IsTrue(ckMechanism81.Mechanism == (ulong)CKM.CKM_AES_CBC);
Assert.IsTrue(ckMechanism81.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism81.ParameterLen == 0);
}
}
}
internal void OnStreamElement(object sender, Node e)
{
if (m_XmppClient == null) return;
if ( m_XmppClient.XmppConnectionState == XmppConnectionState.Securing
|| m_XmppClient.XmppConnectionState == XmppConnectionState.StartCompression)
return;
if (e is Features)
{
Features f = e as Features;
if (!m_XmppClient.Authenticated)
{
// RECV: <stream:features><mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>
// <mechanism>DIGEST-MD5</mechanism><mechanism>PLAIN</mechanism>
// </mechanisms>
// <register xmlns='http://jabber.org/features/iq-register'/>
// </stream:features>
// SENT: <auth mechanism="DIGEST-MD5" xmlns="urn:ietf:params:xml:ns:xmpp-sasl"/>
// Select a SASL mechanism
SaslEventArgs args = new SaslEventArgs(f.Mechanisms);
if (OnSaslStart != null)
OnSaslStart(this, args);
if (args.Auto)
{
// Library handles the Sasl stuff
if (f.Mechanisms!=null)
{
if (m_XmppClient.UseStartTLS == false && m_XmppClient.UseSSL == false
&& f.Mechanisms.SupportsMechanism(MechanismType.X_GOOGLE_TOKEN) )
{
// This is the only way to connect to GTalk on a unsecure Socket for now
// Secure authentication is done over https requests to pass the
// authentication credentials on a secure connection
args.Mechanism = protocol.sasl.Mechanism.GetMechanismName(MechanismType.X_GOOGLE_TOKEN);
}
#if !(CF || CF_2)
else if (m_XmppClient.UseSso && f.Mechanisms.SupportsMechanism(MechanismType.GSSAPI))
{
args.Mechanism = protocol.sasl.Mechanism.GetMechanismName(MechanismType.GSSAPI);
string kerbPrinc = f.Mechanisms.GetMechanism(MechanismType.GSSAPI).KerberosPrincipal;
if (kerbPrinc != null)
m_XmppClient.KerberosPrincipal =
f.Mechanisms.GetMechanism(MechanismType.GSSAPI).KerberosPrincipal;
}
#endif
else if (f.Mechanisms.SupportsMechanism(MechanismType.SCRAM_SHA_1))
{
args.Mechanism = protocol.sasl.Mechanism.GetMechanismName(MechanismType.SCRAM_SHA_1);
}
else if (f.Mechanisms.SupportsMechanism(MechanismType.DIGEST_MD5))
{
args.Mechanism = protocol.sasl.Mechanism.GetMechanismName(MechanismType.DIGEST_MD5);
}
else if (f.Mechanisms.SupportsMechanism(MechanismType.PLAIN))
{
args.Mechanism = protocol.sasl.Mechanism.GetMechanismName(MechanismType.PLAIN);
}
else
{
args.Mechanism = null;
}
}
else
{
// Hack for Google
// TODO: i don't think we need this anymore. This was in an very early version of the gtalk server.
args.Mechanism = null;
//args.Mechanism = agsXMPP.protocol.sasl.Mechanism.GetMechanismName(agsXMPP.protocol.sasl.MechanismType.PLAIN);
}
}
if (args.Mechanism != null)
{
m_Mechanism = Factory.SaslFactory.GetMechanism(args.Mechanism);
// Set properties for the SASL mechanism
m_Mechanism.Username = m_XmppClient.Username;
m_Mechanism.Password = m_XmppClient.Password;
m_Mechanism.Server = m_XmppClient.Server;
m_Mechanism.ExtentedData = args.ExtentedData;
// Call Init Method on the mechanism
m_Mechanism.Init(m_XmppClient);
}
else
{
m_XmppClient.RequestLoginInfo();
}
}
else if(!m_XmppClient.Binded)
{
if (f.SupportsBind)
{
m_XmppClient.DoChangeXmppConnectionState(XmppConnectionState.Binding);
BindIq bIq = string.IsNullOrEmpty(m_XmppClient.Resource) ? new BindIq(IqType.set) : new BindIq(IqType.set, m_XmppClient.Resource);
m_XmppClient.IqGrabber.SendIq(bIq, BindResult, null);
}
}
}
else if (e is Challenge)
{
if (m_Mechanism != null && !m_XmppClient.Authenticated)
{
m_Mechanism.Parse(e);
}
}
else if (e is Success)
{
// SASL authentication was successfull
if (OnSaslEnd!=null)
OnSaslEnd(this);
m_XmppClient.DoChangeXmppConnectionState(XmppConnectionState.Authenticated);
m_Mechanism = null;
m_XmppClient.Reset();
}
else if (e is Failure)
{
// Authentication failure
m_XmppClient.FireOnAuthError(e as Element);
}
}
// Dispose(bool disposing) executes in two distinct scenarios.
// If disposing equals true, the method has been called directly
// or indirectly by a user's code. Managed and unmanaged resources
// can be disposed.
// If disposing equals false, the method has been called by the
// runtime from inside the finalizer and you should not reference
// other objects. Only unmanaged resources can be disposed.
private void Dispose(bool disposing)
{
// Check to see if Dispose has already been called.
if(!m_Disposed)
{
// If disposing equals true, dispose all managed
// and unmanaged resources.
if(disposing)
{
// Dispose managed resources.
// Remove the event handler or we will be in trouble with too many events
m_XmppClient.StreamParser.OnStreamElement -= OnStreamElement;
m_XmppClient = null;
m_Mechanism = null;
}
// Call the appropriate methods to clean up
// unmanaged resources here.
// If disposing is false,
// only the following code is executed.
}
m_Disposed = true;
}
public void _04_ObjectParameterTest()
{
byte[] data = new byte[24];
System.Random rng = new Random();
rng.NextBytes(data);
// Specify mechanism parameters
HLA.MechanismParams.CkKeyDerivationStringData parameter = new HLA.MechanismParams.CkKeyDerivationStringData(data);
// Create mechanism with the object as parameter
Mechanism mechanism = new Mechanism(CKM.CKM_XOR_BASE_AND_DATA, parameter);
Assert.IsTrue(mechanism.Type == (ulong)CKM.CKM_XOR_BASE_AND_DATA);
// We access private Mechanism member here just for the testing purposes
if (Platform.UnmanagedLongSize == 4)
{
if (Platform.StructPackingSize == 0)
{
HLA40.Mechanism mechanism40 = (HLA40.Mechanism)typeof(Mechanism).GetField("_mechanism40", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA40.CK_MECHANISM ckMechanism40 = (LLA40.CK_MECHANISM)typeof(HLA40.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism40);
Assert.IsTrue(ckMechanism40.Mechanism == (uint)CKM.CKM_XOR_BASE_AND_DATA);
Assert.IsTrue(ckMechanism40.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism40.ParameterLen) == UnmanagedMemory.SizeOf(typeof(LLA40.MechanismParams.CK_KEY_DERIVATION_STRING_DATA)));
}
else
{
HLA41.Mechanism mechanism41 = (HLA41.Mechanism)typeof(Mechanism).GetField("_mechanism41", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA41.CK_MECHANISM ckMechanism41 = (LLA41.CK_MECHANISM)typeof(HLA41.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism41);
Assert.IsTrue(ckMechanism41.Mechanism == (uint)CKM.CKM_XOR_BASE_AND_DATA);
Assert.IsTrue(ckMechanism41.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism41.ParameterLen) == UnmanagedMemory.SizeOf(typeof(LLA41.MechanismParams.CK_KEY_DERIVATION_STRING_DATA)));
}
}
else
{
if (Platform.StructPackingSize == 0)
{
HLA80.Mechanism mechanism80 = (HLA80.Mechanism)typeof(Mechanism).GetField("_mechanism80", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA80.CK_MECHANISM ckMechanism80 = (LLA80.CK_MECHANISM)typeof(HLA80.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism80);
Assert.IsTrue(ckMechanism80.Mechanism == (ulong)CKM.CKM_XOR_BASE_AND_DATA);
Assert.IsTrue(ckMechanism80.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism80.ParameterLen) == UnmanagedMemory.SizeOf(typeof(LLA80.MechanismParams.CK_KEY_DERIVATION_STRING_DATA)));
}
else
{
HLA81.Mechanism mechanism81 = (HLA81.Mechanism)typeof(Mechanism).GetField("_mechanism81", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA81.CK_MECHANISM ckMechanism81 = (LLA81.CK_MECHANISM)typeof(HLA81.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism81);
Assert.IsTrue(ckMechanism81.Mechanism == (ulong)CKM.CKM_XOR_BASE_AND_DATA);
Assert.IsTrue(ckMechanism81.Parameter != IntPtr.Zero);
Assert.IsTrue(Convert.ToInt32(ckMechanism81.ParameterLen) == UnmanagedMemory.SizeOf(typeof(LLA81.MechanismParams.CK_KEY_DERIVATION_STRING_DATA)));
}
}
}
public void _02_EmptyParameterTest()
{
// Create mechanism without the parameter
Mechanism mechanism = new Mechanism(CKM.CKM_RSA_PKCS);
Assert.IsTrue(mechanism.Type == (ulong)CKM.CKM_RSA_PKCS);
// We access private Mechanism member just for the testing purposes
if (Platform.UnmanagedLongSize == 4)
{
if (Platform.StructPackingSize == 0)
{
HLA40.Mechanism mechanism40 = (HLA40.Mechanism)typeof(Mechanism).GetField("_mechanism40", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA40.CK_MECHANISM ckMechanism40 = (LLA40.CK_MECHANISM)typeof(HLA40.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism40);
Assert.IsTrue(ckMechanism40.Mechanism == (uint)CKM.CKM_RSA_PKCS);
Assert.IsTrue(ckMechanism40.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism40.ParameterLen == 0);
}
else
{
HLA41.Mechanism mechanism41 = (HLA41.Mechanism)typeof(Mechanism).GetField("_mechanism41", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA41.CK_MECHANISM ckMechanism41 = (LLA41.CK_MECHANISM)typeof(HLA41.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism41);
Assert.IsTrue(ckMechanism41.Mechanism == (uint)CKM.CKM_RSA_PKCS);
Assert.IsTrue(ckMechanism41.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism41.ParameterLen == 0);
}
}
else
{
if (Platform.StructPackingSize == 0)
{
HLA80.Mechanism mechanism80 = (HLA80.Mechanism)typeof(Mechanism).GetField("_mechanism80", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA80.CK_MECHANISM ckMechanism80 = (LLA80.CK_MECHANISM)typeof(HLA80.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism80);
Assert.IsTrue(ckMechanism80.Mechanism == (ulong)CKM.CKM_RSA_PKCS);
Assert.IsTrue(ckMechanism80.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism80.ParameterLen == 0);
}
else
{
HLA81.Mechanism mechanism81 = (HLA81.Mechanism)typeof(Mechanism).GetField("_mechanism81", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism);
LLA81.CK_MECHANISM ckMechanism81 = (LLA81.CK_MECHANISM)typeof(HLA81.Mechanism).GetField("_ckMechanism", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(mechanism81);
Assert.IsTrue(ckMechanism81.Mechanism == (ulong)CKM.CKM_RSA_PKCS);
Assert.IsTrue(ckMechanism81.Parameter == IntPtr.Zero);
Assert.IsTrue(ckMechanism81.ParameterLen == 0);
}
}
}
public NArticulatedPlanarController(Mechanism robot)
{
this.robot = robot;
pointList = new List<double[]>();
}
