/// <summary>
/// Disables encryption on the given disk volume.
/// </summary>
/// <param name="volumeType">The disk volume.</param>
/// <return>An observable that emits the decryption status.</return>
///GENMHASH:B980B0A762D67885E3B127392FD42890:A65E5C07D8DA37A2AB5EC199276933B9
internal async Task <Microsoft.Azure.Management.Compute.Fluent.IDiskVolumeEncryptionMonitor> DisableEncryptionAsync(DiskVolumeType volumeType, CancellationToken cancellationToken = default(CancellationToken))
{
EnableDisableEncryptConfig encryptConfig = new DisableEncryptConfig(volumeType);
await ValidateBeforeDecryptAsync(volumeType, cancellationToken);
// Update the encryption extension if already installed
//
IVirtualMachine virtualMachine = await UpdateEncryptionExtensionAsync(encryptConfig, cancellationToken);
if (virtualMachine == null)
{
// If encryption extension is not then install it
//
virtualMachine = await InstallEncryptionExtensionAsync(encryptConfig, cancellationToken);
}
// Validate and retrieve the encryption extension status
//
string status = await RetrieveEncryptionExtensionStatusStringAsync(ERROR_ENCRYPTION_EXTENSION_STATUS_IS_EMPTY, cancellationToken);
// Update the VM's OS profile by marking encryption disabled
//
virtualMachine = await UpdateVMStorageProfileAsync(encryptConfig, cancellationToken);
// Gets the encryption status
//
return(await GetDiskVolumeEncryptDecryptStatusAsync(virtualMachine, cancellationToken));
}
public VirtualMachine(
string subscriptionId,
IVirtualMachine virtualMachine,
ILogger logger,
IEnumerable <Setting> settings,
NotificationDelay notificationDelay,
ResourceGroup resourceGroup,
LocationTZ timezone,
DateTime timeNowUtc
)
{
this.subscriptionId = subscriptionId;
this.virtualMachine = virtualMachine;
this.logger = logger;
this.settings = settings;
this.notificationDelay = notificationDelay;
this.resourceGroup = resourceGroup;
this.timezones = timezone.GetAll();
this.timeNowUtc = timeNowUtc;
// Using the settings, set the start and stop time for the vm
startTime = settings.First(s => s.name == "vm_start").value;
stopTime = settings.First(s => s.name == "vm_stop").value;
SetPowerState();
}
public static void RegisterTo(IVirtualMachine vm)
{
var jumpMachine = new JumpMachine(vm.Instructions);
vm.RegisterCommand('[', b => jumpMachine.OnBrace(b));
vm.RegisterCommand(']', b => jumpMachine.OnBrace(b));
}
async Task DecorateWithNetworkProperties(IVirtualMachine vm, VmExtendedDto vmDto, CancellationToken cancellationToken)
{
var primaryNic = await _azure.NetworkInterfaces.GetByIdAsync(vm.PrimaryNetworkInterfaceId, cancellationToken);
vmDto.PrivateIp = primaryNic.PrimaryPrivateIP;
try
{
if (primaryNic.PrimaryIPConfiguration != null)
{
var pip = await _azure.PublicIPAddresses.GetByIdAsync(primaryNic.PrimaryIPConfiguration.PublicIPAddressId, cancellationToken);
if (pip != null)
{
vmDto.PublicIp = pip.IPAddress;
}
}
}
catch (Exception ex)
{
_logger.LogWarning(ex, $"Unable to fetch public IP settings for VM {vm.Name}");
}
vmDto.NICs.Add(CreateNicDto(primaryNic));
foreach (var curNic in vm.NetworkInterfaceIds)
{
vmDto.NICs.Add(await CreateNicDto(curNic, cancellationToken));
}
}
public static void InjectMembers(this IVirtualMachine virtualMachine, GamePatch gamePatch, Type type)
{
if (((AvailableSinceAttribute)Attribute.GetCustomAttribute(type, typeof(AvailableSinceAttribute)))?.AvailableSince > gamePatch)
{
return;
}
foreach (var member in type.GetMembers())
{
if (((AvailableSinceAttribute)Attribute.GetCustomAttribute(member, typeof(AvailableSinceAttribute)))?.AvailableSince > gamePatch)
{
continue;
}
if (member.DeclaringType == type)
{
if (member is FieldInfo field)
{
virtualMachine.InjectField(field);
}
else if (member is MethodInfo method)
{
virtualMachine.InjectMethod(method);
}
}
}
}
public static void RegisterTo(IVirtualMachine vm)
{
var pogoStick = new PogoStick(vm.Instructions);
vm.RegisterCommand('[', b => pogoStick.OnBrace(b));
vm.RegisterCommand(']', b => pogoStick.OnBrace(b));
}
public static void RegisterTo(IVirtualMachine vm)
{
var halfLoops = new Stack <Loop>();
startLoops = new Dictionary <int, Loop>();
endLoops = new Dictionary <int, Loop>();
for (int position = 0; position < vm.Instructions.Length; position++)
{
if (vm.Instructions[position] == '[')
{
halfLoops.Push(new Loop(position));
}
else if (vm.Instructions[position] == ']')
{
var loop = halfLoops.Pop();
loop.End = position;
startLoops.Add(loop.Start, loop);
endLoops.Add(loop.End, loop);
}
}
vm.RegisterCommand('[', b => {
if (vm.Memory[vm.MemoryPointer] == 0)
{
vm.InstructionPointer = startLoops[vm.InstructionPointer].End;
}
});
vm.RegisterCommand(']', b => {
if (vm.Memory[vm.MemoryPointer] != 0)
{
vm.InstructionPointer = endLoops[vm.InstructionPointer].Start;
}
});
}
public static void Constants(IVirtualMachine vm)
{
foreach (var chars in constant)
{
vm.RegisterCommand(chars, machine => machine.Memory[machine.MemoryPointer] = (byte)chars);
}
}
/// <summary>
/// Disables encryption on the given disk volume.
/// </summary>
/// <param name="volumeType">The disk volume.</param>
/// <return>An observable that emits the decryption status.</return>
///GENMHASH:B980B0A762D67885E3B127392FD42890:A65E5C07D8DA37A2AB5EC199276933B9
internal async Task <Microsoft.Azure.Management.Compute.Fluent.IDiskVolumeEncryptionMonitor> DisableEncryptionAsync(DiskVolumeType volumeType, CancellationToken cancellationToken = default(CancellationToken))
{
var encryptConfig = EncryptionSettings.CreateDisable(volumeType);
await ValidateBeforeDecryptAsync(volumeType, cancellationToken);
// Update the encryption extension if already installed
//
IVirtualMachineExtension extension = await GetEncryptionExtensionInstalledInVMAsync(cancellationToken);
IVirtualMachine virtualMachine = await UpdateEncryptionExtensionAsync(encryptConfig, extension, cancellationToken);
bool isNoAAD = EncryptionExtensionIdentifier.IsNoAADVersion(osType, extension.VersionName);
if (virtualMachine != null && !isNoAAD)
{
// Validate and retrieve the encryption extension status
//
string status = await RetrieveEncryptionExtensionStatusStringAsync(ERROR_ENCRYPTION_EXTENSION_STATUS_IS_EMPTY, cancellationToken);
// Update the VM's OS profile by marking encryption disabled
//
virtualMachine = await UpdateVMStorageProfileAsync(encryptConfig, cancellationToken);
}
// Gets the encryption status
//
return(await GetDiskVolumeEncryptDecryptStatusAsync(virtualMachine, isNoAAD, cancellationToken));
}
// Сдвинуть указатель памяти вправо/влево на 1 байт
private static void RegisterRigthSNLefthift(IVirtualMachine vm)
{
vm.RegisterCommand('>', vMachine =>
{
// Если указатель памяти указывает на последнюю ячейку памяти, то ставим его в начало
if (vMachine.MemoryPointer + 1 == vMachine.Memory.Length)
{
vMachine.MemoryPointer = 0;
}
else
{
vMachine.MemoryPointer++;
}
});
vm.RegisterCommand('<', vMachine =>
{
if (vMachine.MemoryPointer == 0) // Аналогично сдвигу вправо
{
vMachine.MemoryPointer = vMachine.Memory.Length - 1;
}
else
{
vMachine.MemoryPointer--;
}
});
}
/// <summary>Convert the Virtual machine to virtual machine crawler response entity.</summary>
/// <param name="virtualMachine">The virtual machine.</param>
/// <param name="partitionKey">The partition key for the virtaul machine entity.</param>
/// <param name="vmGroup">Vm group name.</param>
/// <returns></returns>
public static VirtualMachineCrawlerResponse ConvertToVirtualMachineEntity(IVirtualMachine virtualMachine, string partitionKey, string vmGroup = "")
{
var virtualMachineCrawlerResponseEntity = new VirtualMachineCrawlerResponse(partitionKey,
virtualMachine.Id.Replace(Delimeters.ForwardSlash, Delimeters.Exclamatory))
{
RegionName = virtualMachine.RegionName,
ResourceGroupName = virtualMachine.ResourceGroupName,
ResourceName = virtualMachine.Name,
AvailabilitySetId = virtualMachine.AvailabilitySetId,
ResourceType = virtualMachine.Type,
AvailabilityZone = virtualMachine.AvailabilityZones.Count > 0 ?
int.Parse(virtualMachine.AvailabilityZones.FirstOrDefault().Value) : 0,
VirtualMachineGroup = string.IsNullOrWhiteSpace(vmGroup) ? VirtualMachineGroup.VirtualMachines.ToString() : vmGroup,
State = virtualMachine.PowerState?.Value
};
if (virtualMachine.InstanceView?.PlatformUpdateDomain > 0)
{
virtualMachineCrawlerResponseEntity.UpdateDomain = virtualMachine.InstanceView.PlatformUpdateDomain;
}
if (virtualMachine.InstanceView?.PlatformFaultDomain > 0)
{
virtualMachineCrawlerResponseEntity.FaultDomain = virtualMachine.InstanceView.PlatformFaultDomain;
}
return(virtualMachineCrawlerResponseEntity);
}
/// <summary>Perform the Chaos Operation</summary>
/// <param name="actionType">Action type</param>
/// <param name="virtualMachine">Virtual Machine</param>
/// <param name="scheduledRules">Event activity entity</param>
/// <returns></returns>
private static void PerformChaosOnVirtualMachine(string action, IVirtualMachine virtualMachine, ScheduledRules scheduledRules, bool enableRollback)
{
ActionType actionType;
if (!Enum.TryParse(action, out actionType))
{
return;
}
switch (actionType)
{
case ActionType.Start:
virtualMachine.StartAsync();
break;
case ActionType.PowerOff:
case ActionType.Stop:
virtualMachine.PowerOffAsync();
break;
case ActionType.Restart:
virtualMachine.RestartAsync();
break;
}
if (enableRollback)
{
scheduledRules.RollbackExecutionStatus = Status.Executing.ToString();
}
else
{
scheduledRules.ExecutionStatus = Status.Executing.ToString();
}
}
public IVirtualMachine GetVMFromAzure(string _vmId)
{
IVirtualMachine machine = null;
using (CADContext context = new CADContext())
{
try
{
IAzure azure;
VM vm = context.VMs.FirstOrDefault(v => v.VMId == _vmId);
Application apps = context.Applications.FirstOrDefault(app => app.AppId == vm.ApplicationId);
azure = GetAzureConnection(apps);
machine = azure.VirtualMachines.List().FirstOrDefault(v => v.VMId == _vmId);
}
catch (Exception ex)
{
Log log = new Log();
log.name = ex.ToString();
log.timestamp = DateTime.UtcNow;
context.Logs.Add(log);
context.SaveChanges();
}
}
return(machine);
}
// Увеличение/уменьшение байта памяти, на который указывает указатель
private static void RegisterIncNDec(IVirtualMachine vm)
{
vm.RegisterCommand('+', vMachine =>
{
// Если значение байта максимально, то при увеличении значение становится 0
if (vMachine.Memory[vMachine.MemoryPointer] == 255)
{
vMachine.Memory[vMachine.MemoryPointer] = 0;
}
else
{
vMachine.Memory[vMachine.MemoryPointer]++;
}
});
vm.RegisterCommand('-', vMachine =>
{
if (vMachine.Memory[vMachine.MemoryPointer] == 0) // Аналогично инкрименту
{
vMachine.Memory[vMachine.MemoryPointer] = 255;
}
else
{
vMachine.Memory[vMachine.MemoryPointer]--;
}
});
}
/**
* It creates a new Azure virtual machine and it instantiate a Java Docker client.
* @param azure - instance of Azure
* @param rgName - name of the Azure resource group to be used when creating a virtual machine
* @param region - region to be used when creating a virtual machine
* @return an instance of DockerClient
*/
public static DockerClient FromNewDockerVM(IAzure azure, String rgName, Region region)
{
string dockerVMName = SdkContext.RandomResourceName("dockervm", 15);
string publicIPDnsLabel = SdkContext.RandomResourceName("pip", 10);
string vmUserName = "******";
string vmPassword = "******";
// Could not find a Docker environment; presume that there is no local Docker engine running and
// attempt to configure a Docker engine running inside a new Azure virtual machine
Utilities.Log("Creating an Azure virtual machine running Docker");
IVirtualMachine dockerVM = azure.VirtualMachines.Define(dockerVMName)
.WithRegion(region)
.WithExistingResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithNewPrimaryPublicIPAddress(publicIPDnsLabel)
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername(vmUserName)
.WithRootPassword(vmPassword)
.WithSize(VirtualMachineSizeTypes.StandardD2V2)
.Create();
Utilities.Log("Created Azure Virtual Machine: " + dockerVM.Id);
// Get the IP of the Docker host
INicIPConfiguration nicIPConfiguration = dockerVM.GetPrimaryNetworkInterface().PrimaryIPConfiguration;
IPublicIPAddress publicIp = nicIPConfiguration.GetPublicIPAddress();
string dockerHostIP = publicIp.IPAddress;
DockerClient dockerClient = InstallDocker(dockerHostIP, vmUserName, vmPassword);
return(dockerClient);
}
public TypeProvider(IVirtualMachine virtualMachine)
{
this.virtualMachine = virtualMachine;
this.virtualMachine.AssemblyLoaded += OnAssemblyLoaded;
this.virtualMachine.AssemblyUnloaded += OnAssemblyUnloaded;
this.virtualMachine.TypeLoaded += OnTypeLoaded;
}
public void GlobalSetup()
{
TrieStore trieStore = new(new MemDb(), new OneLoggerLogManager(NullLogger.Instance));
IKeyValueStore codeDb = new MemDb();
_stateProvider = new StateProvider(trieStore, codeDb, new OneLoggerLogManager(NullLogger.Instance));
_stateProvider.CreateAccount(Address.Zero, 1000.Ether());
_stateProvider.Commit(_spec);
_storageProvider = new StorageProvider(trieStore, _stateProvider, new OneLoggerLogManager(NullLogger.Instance));
_worldState = new WorldState(_stateProvider, _storageProvider);
Console.WriteLine(MuirGlacier.Instance);
_virtualMachine = new VirtualMachine(_blockhashProvider, MainnetSpecProvider.Instance, new OneLoggerLogManager(NullLogger.Instance));
_environment = new ExecutionEnvironment
{
ExecutingAccount = Address.Zero,
CodeSource = Address.Zero,
Caller = Address.Zero,
CodeInfo = new CodeInfo(Bytecode),
Value = 0,
TransferValue = 0,
TxExecutionContext = new TxExecutionContext(_header, Address.Zero, 0)
};
_evmState = new EvmState(100_000_000L, _environment, ExecutionType.Transaction, true, _worldState.TakeSnapshot(), false);
}
// Добавление констант
private static void RegisterConstants(IVirtualMachine vm)
{
foreach (var c in consts)
{
vm.RegisterCommand(c, vMachine => vMachine.Memory[vMachine.MemoryPointer] = (byte)c);
}
}
/// <summary>
/// Enables encryption.
/// </summary>
/// <param name="encryptionSettings">The settings to be used for encryption extension.</param>
/// <param name="">The Windows or Linux encryption settings.</param>
/// <return>An observable that emits the encryption status.</return>
///GENMHASH:FB7DBA27A41CC76685F21AB0A9729C82:D88D73A86520940C4EA57E9CEEA1516F
internal async Task <IDiskVolumeEncryptionMonitor> EnableEncryptionAsync <T>(VirtualMachineEncryptionConfiguration <T> encryptionSettings,
CancellationToken cancellationToken = default(CancellationToken)) where T : VirtualMachineEncryptionConfiguration <T>
{
var encryptConfig = new EnableEncryptConfig <T>(encryptionSettings);
// Update the encryption extension if already installed
//
IVirtualMachine virtualMachine = await UpdateEncryptionExtensionAsync(encryptConfig, cancellationToken);
if (virtualMachine == null)
{
// If encryption extension is not installed then install it
//
virtualMachine = await InstallEncryptionExtensionAsync(encryptConfig, cancellationToken);
}
// Retrieve the encryption key URL after extension install or update
//
string keyVaultSecretUrl = await RetrieveEncryptionExtensionStatusStringAsync(ERROR_EXPECTED_KEY_VAULT_URL_NOT_FOUND, cancellationToken);
// Update the VM's OS Disk (in storage profile) with the encryption metadata
//
virtualMachine = await UpdateVMStorageProfileAsync(encryptConfig, keyVaultSecretUrl, cancellationToken);
// Gets the encryption status
//
return(await GetDiskVolumeEncryptDecryptStatusAsync(virtualMachine, cancellationToken));
}
public void GlobalSetup()
{
ISnapshotableDb codeDb = new StateDb();
ISnapshotableDb stateDb = new StateDb();
IDb blockInfoDb = new MemDb(10, 5);
ISpecProvider specProvider = MainNetSpecProvider.Instance;
IReleaseSpec spec = MainNetSpecProvider.Instance.GenesisSpec;
StateProvider stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
stateProvider.CreateAccount(Address.Zero, 1000.Ether());
stateProvider.Commit(spec);
StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, LimboLogs.Instance);
StateReader stateReader = new StateReader(stateDb, codeDb, LimboLogs.Instance);
ChainLevelInfoRepository chainLevelInfoRepository = new ChainLevelInfoRepository(blockInfoDb);
BlockTree blockTree = new BlockTree(new MemDb(), new MemDb(), blockInfoDb, chainLevelInfoRepository, specProvider, NullTxPool.Instance, LimboLogs.Instance);
_blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
_virtualMachine = new VirtualMachine(stateProvider, storageProvider, _blockhashProvider, specProvider, LimboLogs.Instance);
Block genesisBlock = Build.A.Block.Genesis.TestObject;
blockTree.SuggestBlock(genesisBlock);
Block block1 = Build.A.Block.WithParent(genesisBlock).WithNumber(1).TestObject;
blockTree.SuggestBlock(block1);
TransactionProcessor transactionProcessor
= new TransactionProcessor(MainNetSpecProvider.Instance, stateProvider, storageProvider, _virtualMachine, LimboLogs.Instance);
BlockProcessor blockProcessor = new BlockProcessor(specProvider, AlwaysValidBlockValidator.Instance, new RewardCalculator(specProvider), transactionProcessor,
stateDb, codeDb, new MemDb(), stateProvider, storageProvider, NullTxPool.Instance, NullReceiptStorage.Instance, LimboLogs.Instance);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(
blockTree,
blockProcessor,
new TxSignaturesRecoveryStep(new EthereumEcdsa(specProvider, LimboLogs.Instance), NullTxPool.Instance, LimboLogs.Instance),
LimboLogs.Instance,
false,
false);
blockchainProcessor.Process(genesisBlock, ProcessingOptions.None, NullBlockTracer.Instance);
blockchainProcessor.Process(block1, ProcessingOptions.None, NullBlockTracer.Instance);
BlockchainBridge bridge = new BlockchainBridge(
stateReader,
stateProvider,
storageProvider,
blockTree,
NullTxPool.Instance,
NullReceiptStorage.Instance,
NullFilterStore.Instance,
NullFilterManager.Instance, new DevWallet(new WalletConfig(), LimboLogs.Instance), transactionProcessor, new EthereumEcdsa(MainNetSpecProvider.Instance, LimboLogs.Instance));
_ethModule = new EthModule(LimboLogs.Instance, bridge);
}
public void CanEnableWithImplicitStorageOnManagedVMCreation()
{
using (var context = FluentMockContext.Start(GetType().FullName))
{
string rgName = TestUtilities.GenerateName("vmbdtest");
string regionName = "eastus";
string vmName = "javavm";
var azure = TestHelper.CreateRollupClient();
IVirtualMachine virtualMachine = azure.VirtualMachines
.Define(vmName)
.WithRegion(regionName)
.WithNewResourceGroup(rgName)
.WithNewPrimaryNetwork("10.0.0.0/28")
.WithPrimaryPrivateIPAddressDynamic()
.WithoutPrimaryPublicIPAddress()
.WithPopularLinuxImage(KnownLinuxVirtualMachineImage.UbuntuServer16_04_Lts)
.WithRootUsername("Foo12")
.WithRootPassword("abc!@#F0orL")
.WithBootDiagnostics()
.Create();
Assert.NotNull(virtualMachine);
Assert.True(virtualMachine.IsBootDiagnosticsEnabled);
Assert.NotNull(virtualMachine.BootDiagnosticsStorageUri);
}
}
public VirtualMachineControl(IVirtualMachine machine)
{
DataContext = this;
InitializeComponent();
Machine = machine;
VMAction.Click += VMAction_Click;
}
public static string GetManagementLink(IVirtualMachine machine)
{
string portalUrl = CombineUris(PortalUrlBase, machine.Id);
string aTag = $"<a href=\"{portalUrl}\">Manage</a>";
return(aTag);
}
public static void RegisterTo(IVirtualMachine vm)
{
var indexOfBrackets = new Stack <int>();
var startBrackets = new Dictionary <int, int>();
var endBrackets = new Dictionary <int, int>();
for (int i = 0; i < vm.Instructions.Length; i++)
{
if (vm.Instructions[i] == '[')
{
indexOfBrackets.Push(i);
}
else if (vm.Instructions[i] == ']')
{
startBrackets[i] = indexOfBrackets.Peek();
endBrackets[indexOfBrackets.Pop()] = i;
}
}
vm.RegisterCommand('[', b => {
if (vm.Memory[vm.MemoryPointer] == 0)
{
vm.InstructionPointer = endBrackets[vm.InstructionPointer];
}
});
vm.RegisterCommand(']', b => vm.InstructionPointer = startBrackets[vm.InstructionPointer] - 1);
}
public static void RegisterTo(IVirtualMachine vm)
{
var indexOfSquareBrackets = new Stack <int>();
var squareBracketsDict = new Dictionary <int, int>();
for (int i = 0; i < vm.Instructions.Length; i++)
{
if (vm.Instructions[i] == '[')
{
indexOfSquareBrackets.Push(i);
}
if (vm.Instructions[i] == ']')
{
var tempIndex = indexOfSquareBrackets.Pop();
squareBracketsDict.Add(tempIndex, i);
squareBracketsDict.Add(i, tempIndex);
}
}
vm.RegisterCommand('[', virtMachine =>
{
if (vm.Memory[vm.MemoryPointer] == 0)
{
vm.InstructionPointer = squareBracketsDict[vm.InstructionPointer];
}
});
vm.RegisterCommand(']', virtMachine =>
{
if (vm.Memory[vm.MemoryPointer] != 0)
{
vm.InstructionPointer = squareBracketsDict[vm.InstructionPointer];
}
});
}
public static void WriteAllSymbols(IVirtualMachine vm)
{
foreach (var symbol in allSymbols)
{
vm.RegisterCommand(symbol, machine => machine.Memory[machine.MemoryPointer] = (byte)symbol);
}
}
public TypeProvider(IVirtualMachine virtualMachine)
{
this.virtualMachine = virtualMachine;
this.virtualMachine.AssemblyLoaded += OnAssemblyLoaded;
this.virtualMachine.AssemblyUnloaded += OnAssemblyUnloaded;
this.virtualMachine.TypeLoaded += OnTypeLoaded;
}
public void Run(IVirtualMachine Runtime, int[] args, char[] types)
{
if (types[0] != 0)
{
throw new VMException(VMFault.InvalidArgs);
}
int memoryAddr;
if (types[1] == 0)
{
memoryAddr = Runtime.Read(args[1]);
}
else
{
memoryAddr = args[1];
}
int offset = args[2];
if (types[2] == 0)
{
offset = Runtime.Read(args[2]);
}
Runtime.Write(args[0], Runtime.Read(memoryAddr + offset));
}
private void CreateStepRequests()
{
IVirtualMachine virtualMachine = _thread.GetVirtualMachine();
IEventRequestManager manager = virtualMachine.GetEventRequestManager();
/*
* THE ORDER OF THESE MUST MATCH THE LOOKUP IN GetStepRequest!
*/
// step into
_stepRequests.Add(manager.CreateStepRequest(_thread, StepSize.Instruction, StepDepth.Into));
_stepRequests.Add(manager.CreateStepRequest(_thread, StepSize.Line, StepDepth.Into));
_stepRequests.Add(manager.CreateStepRequest(_thread, StepSize.Statement, StepDepth.Into));
// step out
_stepRequests.Add(manager.CreateStepRequest(_thread, StepSize.Instruction, StepDepth.Out));
_stepRequests.Add(manager.CreateStepRequest(_thread, StepSize.Line, StepDepth.Out));
_stepRequests.Add(manager.CreateStepRequest(_thread, StepSize.Statement, StepDepth.Out));
// step over
_stepRequests.Add(manager.CreateStepRequest(_thread, StepSize.Instruction, StepDepth.Over));
_stepRequests.Add(manager.CreateStepRequest(_thread, StepSize.Line, StepDepth.Over));
_stepRequests.Add(manager.CreateStepRequest(_thread, StepSize.Statement, StepDepth.Over));
foreach (var request in _stepRequests)
{
request.SuspendPolicy = SuspendPolicy.All;
}
}
public void GlobalSetup()
{
ByteCode = Bytes.FromHexString(Environment.GetEnvironmentVariable("NETH.BENCHMARK.BYTECODE"));
Console.WriteLine($"Running benchmark for bytecode {ByteCode?.ToHexString()}");
IDb codeDb = new StateDb();
ISnapshotableDb stateDb = new StateDb();
_stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
_stateProvider.CreateAccount(Address.Zero, 1000.Ether());
_stateProvider.Commit(_spec);
_storageProvider = new StorageProvider(stateDb, _stateProvider, LimboLogs.Instance);
_virtualMachine = new VirtualMachine(_stateProvider, _storageProvider, _blockhashProvider, MainnetSpecProvider.Instance, LimboLogs.Instance);
_environment = new ExecutionEnvironment();
_environment.ExecutingAccount = Address.Zero;
_environment.CodeSource = Address.Zero;
_environment.Originator = Address.Zero;
_environment.Sender = Address.Zero;
_environment.CodeInfo = new CodeInfo(ByteCode);
_environment.GasPrice = 0;
_environment.Value = 0;
_environment.TransferValue = 0;
_environment.CurrentBlock = _header;
_evmState = new EvmState(long.MaxValue, _environment, ExecutionType.Transaction, true, false);
}
public static void RegisterTo(IVirtualMachine vm, Func <int> read, Action <char> write)
{
// Вывести байт памяти, на который указывает указатель, преобразовав в символ согласно ASCII
vm.RegisterCommand('.', b => { write(Convert.ToChar(b.Memory[b.MemoryPointer])); });
// Увеличить байт памяти, на который указывает указатель
vm.RegisterCommand('+', b => { b.Memory[b.MemoryPointer] = Convert.ToByte((b.Memory[b.MemoryPointer] + 1) & 0xFF); });
// Уменьшить байт памяти, на который указывает указатель
vm.RegisterCommand('-', b => { b.Memory[b.MemoryPointer] = Convert.ToByte((b.Memory[b.MemoryPointer] + 255) & 0xFF); });
// Ввести символ и сохранить его ASCII-код в байт памяти, на который указывает указатель
vm.RegisterCommand(',', b => { b.Memory[b.MemoryPointer] = Convert.ToByte(read()); });
// Сдвинуть указатель памяти вправо на 1 байт
vm.RegisterCommand('>', b => { b.MemoryPointer = (b.MemoryPointer + 1) % b.Memory.Length; });
// Сдвинуть указатель памяти влево на 1 байт
vm.RegisterCommand('<', b =>
{
b.MemoryPointer = (b.MemoryPointer + b.Memory.Length - 1) % b.Memory.Length;
});
// сохранить ASCII-код этого символа в байт памяти, на который указывает указатель
const string literals = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
for (var ix = 0; ix < literals.Length; ix++)
{
var literal = literals[ix];
vm.RegisterCommand(literal, b => { b.Memory[b.MemoryPointer] = Convert.ToByte(literal); });
}
}
public DebuggerSession(IVirtualMachine vm, ITypeProvider typeProvider,
IExecutionProvider executionProvider, IThreadProvider threadProvider,
IBreakpointProvider breakpointProvider)
{
this.typeProvider = typeProvider;
this.executionProvider = executionProvider;
this.threadProvider = threadProvider;
this.breakpointProvider = breakpointProvider;
this.vm = vm;
}
public DebuggerSession(IVirtualMachine virtualMachine,
IExecutionProvider executionProvider, ITypeProvider typeProvider,
IThreadProvider threadProvider, IBreakpointProvider breakpointProvider)
{
VM = virtualMachine;
ExecutionProvider = executionProvider;
ThreadProvider = threadProvider;
TypeProvider = typeProvider;
BreakpointProvider = breakpointProvider;
}
public ExecutionProvider(IVirtualMachine vm)
{
this.vm = vm;
this.vm.VMSuspended += VMSuspended;
this.vm.Stepped += OnStepped;
this.vm.ThreadStarted += OnThreadStarted;
this.vm.BreakpointHit += OnBreakpointHit;
currentLocation = null;
currentThread = null;
running = true;
}
public DebuggerSession(IVirtualMachine vm, ITypeProvider typeProvider,
IExecutionProvider executionProvider, IThreadProvider threadProvider,
IBreakpointProvider breakpointProvider)
{
this.typeProvider = typeProvider;
this.executionProvider = executionProvider;
this.threadProvider = threadProvider;
this.breakpointProvider = breakpointProvider;
this.vm = vm;
LogProvider.Debug += s => LogOnDebug (s);
LogProvider.Error += s => LogOnError (s);
}
private IVirtualMachine CreateVirtualMachine()
{
return _virtualMachine = new SphereVirtualMachine( _vmWareVirtualMachine );
}
internal void InitializeDebuggerChannel(JavaDebugEngine debugEngine, IDebugEventCallback2 callback)
{
Contract.Requires<ArgumentNullException>(debugEngine != null, "debugEngine");
Contract.Requires<ArgumentNullException>(callback != null, "callback");
_debugEngine = debugEngine;
_callback = callback;
var connector = new LocalDebuggingAttachingConnector();
Dictionary<string, IConnectorArgument> arguments = new Dictionary<string, IConnectorArgument>();
string argumentName = "pid";
IConnectorIntegerArgument defaultArgument = (IConnectorIntegerArgument)connector.DefaultArguments[argumentName];
IConnectorIntegerArgument argument = new ConnectorIntegerArgument(defaultArgument, (int)_process.GetPhysicalProcessId().dwProcessId);
arguments.Add(argumentName, argument);
argumentName = "sourcePaths";
IConnectorStringArgument defaultPathsArgument = (IConnectorStringArgument)connector.DefaultArguments[argumentName];
List<string> sourcePaths = GetSourcePaths();
IConnectorStringArgument stringArgument = new ConnectorStringArgument(defaultPathsArgument, string.Join(";", sourcePaths));
arguments.Add(argumentName, stringArgument);
connector.AttachComplete += HandleAttachComplete;
_virtualMachine = connector.Attach(arguments);
IVirtualMachineEvents events = _virtualMachine.GetEventQueue() as IVirtualMachineEvents;
if (events != null)
{
events.VirtualMachineStart += HandleVirtualMachineStart;
events.VirtualMachineDeath += HandleVirtualMachineDeath;
events.SingleStep += HandleSingleStep;
events.Breakpoint += HandleBreakpoint;
events.MethodEntry += HandleMethodEntry;
events.MethodExit += HandleMethodExit;
events.MonitorContendedEnter += HandleMonitorContendedEnter;
events.MonitorContendedEntered += HandleMonitorContendedEntered;
events.MonitorContendedWait += HandleMonitorContendedWait;
events.MonitorContendedWaited += HandleMonitorContendedWaited;
events.Exception += HandleException;
events.ThreadStart += HandleThreadStart;
events.ThreadDeath += HandleThreadDeath;
events.ClassPrepare += HandleClassPrepare;
events.ClassUnload += HandleClassUnload;
events.FieldAccess += HandleFieldAccess;
events.FieldModification += HandleFieldModification;
}
}
public CreateVirtualMachineService(IVirtualMachine ivm)
{
}
public VirtualMachineIsNotReadyException( IVirtualMachine virtualMachine, string message ):base(message)
{
VirtualMachine = virtualMachine;
}
public void SetUp()
{
_vm = SetupVirtualMachineRunning (CompileSimpleProgram ());
}
public Shell(IVirtualMachine virtualMachine)
{
if (virtualMachine == null) throw new ArgumentNullException("virtualMachine");
VirtualMachine = virtualMachine;
}
public RegisteredVirtualMachineService(string imagePathName)
{
GetVirtualHost();
VM = virtualHost.Open(imagePathName);
}
public void Destroy(IVirtualMachine vm)
{
((Regulus.Framework.ILaunched)vm).Shutdown();
}
/// <summary>
/// A constructor for the system environment.
/// </summary>
/// <param name="vm"></param>
public SystemEnvironment(IVirtualMachine vm = null)
{
VirtualMachine = vm;
Bind(Time, "time", null, new { time = new[] { "datetime", "date", "now" } });
Bind(Exit, "exit", null, new { exit = new[] { "quit" } });
}
private void Stop()
{
AddText("Stopping...");
Terminating = true;
SetEnabled(false, StopButton);
SetEnabled(true, BreakOnStartCheckBox);
SetEnabled(true, StartButton);
if (theVM != null && theVM.PoweredOn)
{
AddText("Stopping VM...");
theVM.PowerOff();
theVM = null;
}
if (TheDebugger != null)
{
AddText(string.Format("Stopped debugger : {0}", TheDebugger.Stop()));
TheDebugger = null;
}
AddText("Stopped.");
AddText("");
}
public ExecutionProvider(IVirtualMachine virtualMachine)
{
this.virtualMachine = virtualMachine;
this.virtualMachine.VMSuspended += VMSuspended;
}
private static void SetEventProperties(DebugEvent debugEvent, IEventRequest request, SuspendPolicy suspendPolicy, IVirtualMachine virtualMachine, IThreadReference thread, bool manualResume)
{
Contract.Requires<ArgumentNullException>(debugEvent != null, "debugEvent");
debugEvent.Properties.AddProperty(typeof(IEventRequest), request);
debugEvent.Properties.AddProperty(typeof(SuspendPolicy), suspendPolicy);
debugEvent.Properties.AddProperty(typeof(IVirtualMachine), virtualMachine);
debugEvent.Properties.AddProperty(typeof(IThreadReference), thread);
debugEvent.Properties.AddProperty("ManualResume", manualResume);
}
public ThreadProvider(IVirtualMachine vm, IExecutionProvider executionProvider)
{
this.vm = vm;
this.executionProvider = executionProvider;
executionProvider.Suspended += Suspended;
}
