LinkedInTwitterFacebook

Programming with FASM – test with CPUID .

By admin | Published 14/09/2017

First you need to take a look at this website.
The CPUID returns processor identification and feature information in the EAX, EBX, ECX, and EDX registers.
What the source code from my example do ?
First I start with the default assembly program .
The next step is to strat with reset xor eax,eax use cpuid.
The result of CPUID will be put into EBX.
Into section ‘.data’ data readable writeable make a structure named out_buffer.
The structure will be fill so you need to EBX, see example:
mov [out_buffer.vendor_ebx],ebx will give us “Genu”.
The next step for test EBX is this example:
test edx,00010000000000000000000000000000b
jz .NoHTT
mov [out_buffer.htt_arch4],’YES ‘
.NoHTT:
The structure of out_buffer is :
db ‘NoHTT’,2,9,’- ‘
.htt_arch4 dd ‘NO ‘
db 9,10
Because I used MessageBox to show us the out_buffer.
The result will be : No or Yes with the size of dd.
The db can define byte variables, as well as arrays of bytes.
Fasm documentation tell us: For example db 1,2,3 will define the three bytes of values 1, 2 and 3 respectively.
The dd has 4 bytes.
The result will be this text (the result is true so the text will be YES): “NoHTT – YES”.
Let’s see one screenshot:

This is the source code:

Assembly (x86)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
format PE GUI 4.0
entry start
 
include 'win32ax.inc'
 
;---  http://x86.renejeschke.de/html/file_module_x86_id_45.html
 
section '.code' code readable executable
 
    start:
 
        ; INVOKE CPUID FUNCTION 0x00000000
 
        xor     eax,eax
        cpuid
 
        ; EXTRACT VENDOR STRING FROM
 
        mov     [out_buffer.vendor_ebx],ebx
        mov     [out_buffer.vendor_edx],edx
        mov     [out_buffer.vendor_ecx],ecx
 
        ; CHECK FOR FUNCTION 0x00000001
 
        cmp     eax,0x00000001
        jl      .NoCPUID_FN1
 
        ; INVOKE CPUID FUNCTION 0x00000001
 
        mov     eax,0x00000001
        cpuid
        ; TEST FOR HTT  Hyper-Threading Technology
 
        test    edx,00010000000000000000000000000000b
        jz      .NoHTT
        mov     [out_buffer.htt_arch4],'YES '
    .NoHTT:
 
        ; TEST FOR MMX
 
        test    edx,00000000100000000000000000000000b
        jz      .NoMMX
        mov     [out_buffer.mmx_ach4],'YES '
    .NoMMX:
 
        ; TEST FOR SSE
 
        test    edx,00000010000000000000000000000000b
        jz      .NoSSE
        mov     [out_buffer.sse_ach4],'YES '
    .NoSSE:
 
        ; TEST FOR SSE2
 
        test    edx,00000100000000000000000000000000b
        jz      .NoSSE2
        mov     [out_buffer.sse2_ach4],'YES '
    .NoSSE2:
 
        ; TEST FOR SSE3
 
        test    ecx,00000000000000000000000000000001b
        jz      .NoSSE3
        mov     [out_buffer.sse3_ach4],'YES '
    .NoSSE3:
 
    .NoCPUID_FN1:
 
        ; DISPLAY RESULTS AND QUIT
 
        invoke  MessageBox,NULL,out_buffer,'CPUID',MB_OK+MB_ICONINFORMATION
        invoke  ExitProcess,0
        jmp     $
 
;---  SECTION DATA STRUCTURE FOR MESSAGE BOX
 
section '.data' data readable writeable
 
    out_buffer:
                        db 'VENDOR',2,9,'- '
      .vendor_ebx       dd 0
      .vendor_edx       dd 0
      .vendor_ecx       dd 0
                        db 9,13,10
 
                        db 'NoHTT',2,9,'- '
      .htt_arch4        dd 'NO  '
                        db 9,10
 
                        db 'MMX',2,9,'- '
      .mmx_ach4         dd 'NO  '
                        db 9,10
 
                        db 'SSE',2,9,'- '
      .sse_ach4         dd 'NO  '
                        db 9,10
 
                        db 'SSE2',2,9,'- '
      .sse2_ach4        dd 'NO  '
                        db 9,10
 
                        db 'SSE3',2,9,'- '
      .sse3_ach4        dd 'NO  '
                        db 9,10
 
                        db 0 ; end out_buffer
 
;---  DEFAULT DATA INCLUDES
 
section '.idata' import data readable
 
    library kernel32,'kernel32.dll',\
            user32,'user32.dll'
 
    include 'api\kernel32.inc'
    include 'api\user32.inc'

Posted in All, Assembler, Windows 10, Windows 7, Windows 8 | Tagged: , , , , , . Leave a Comment

Windows 10 – sc command .

By admin | Published 13/09/2017

The sc command help us to retrieves and sets control information about services.

Shell
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
sc
DESCRIPTION:
        SC is a command line program used for communicating with the
        Service Control Manager and services.
USAGE:
        sc <server> [command] [service name] <option1> <option2>...
 
 
        The option <server> has the form "\\ServerName"
        Further help on commands can be obtained by typing: "sc [command]"
        Commands:
          query-----------Queries the status for a service, or
                          enumerates the status for types of services.
          queryex---------Queries the extended status for a service, or
                          enumerates the status for types of services.
          start-----------Starts a service.
          pause-----------Sends a PAUSE control request to a service.
          interrogate-----Sends an INTERROGATE control request to a service.
          continue--------Sends a CONTINUE control request to a service.
          stop------------Sends a STOP request to a service.
          config----------Changes the configuration of a service (persistent).
          description-----Changes the description of a service.
          failure---------Changes the actions taken by a service upon failure.
          failureflag-----Changes the failure actions flag of a service.
          sidtype---------Changes the service SID type of a service.
          privs-----------Changes the required privileges of a service.
          managedaccount--Changes the service to mark the service account
                          password as managed by LSA.
          qc--------------Queries the configuration information for a service.
          qdescription----Queries the description for a service.
          qfailure--------Queries the actions taken by a service upon failure.
          qfailureflag----Queries the failure actions flag of a service.
          qsidtype--------Queries the service SID type of a service.
          qprivs----------Queries the required privileges of a service.
          qtriggerinfo----Queries the trigger parameters of a service.
          qpreferrednode--Queries the preferred NUMA node of a service.
          qmanagedaccount-Queries whether a services uses an account with a
                          password managed by LSA.
          qprotection-----Queries the process protection level of a service.
          quserservice----Queries for a local instance of a user service template.
          delete----------Deletes a service (from the registry).
          create----------Creates a service. (adds it to the registry).
          control---------Sends a control to a service.
          sdshow----------Displays a service's security descriptor.
          sdset-----------Sets a service's security descriptor.
          showsid---------Displays the service SID string corresponding to an arbitrary name.
          triggerinfo-----Configures the trigger parameters of a service.
          preferrednode---Sets the preferred NUMA node of a service.
          GetDisplayName--Gets the DisplayName for a service.
          GetKeyName------Gets the ServiceKeyName for a service.
          EnumDepend------Enumerates Service Dependencies.
 
        The following commands don't require a service name:
        sc <server> <command> <option>
          boot------------(ok | bad) Indicates whether the last boot should
                          be saved as the last-known-good boot configuration
          Lock------------Locks the Service Database
          QueryLock-------Queries the LockStatus for the SCManager Database
EXAMPLE:
        sc start MyService
 
 
QUERY and QUERYEX OPTIONS:
        If the query command is followed by a service name, the status
        for that service is returned.  Further options do not apply in
        this case.  If the query command is followed by nothing or one of
        the options listed below, the services are enumerated.
    type=    Type of services to enumerate (driver, service, userservice, all)
             (default = service)
    state=   State of services to enumerate (inactive, all)
             (default = active)
    bufsize= The size (in bytes) of the enumeration buffer
             (default = 4096)
    ri=      The resume index number at which to begin the enumeration
             (default = 0)
    group=   Service group to enumerate
             (default = all groups)
 
SYNTAX EXAMPLES
sc query                - Enumerates status for active services & drivers
sc query eventlog       - Displays status for the eventlog service
sc queryex eventlog     - Displays extended status for the eventlog service
sc query type= driver   - Enumerates only active drivers
sc query type= service  - Enumerates only Win32 services
sc query state= all     - Enumerates all services & drivers
sc query bufsize= 50    - Enumerates with a 50 byte buffer
sc query ri= 14         - Enumerates with resume index = 14
sc queryex group= ""    - Enumerates active services not in a group
sc query type= interact - Enumerates all interactive services
sc query type= driver group= NDIS     - Enumerates all NDIS drivers

Some options of this command:

Shell
1
2
3
4
5
6
7
8
9
10
11
sc config Configures service startup and login accounts
sc continue Resumes a paused service
sc enumdepend
Lists the services that cannot run unless the specified service is running
 
sc failure Specifies what action to take upon failure of the service
sc pause Pauses a service
sc qc Displays the configuration of a particular service
sc query Displays information about the specified service, driver, type of service, or type of driver
sc start Starts a service running
sc stop Sends a STOP request to a service (not all will respond)

Let’s test query with intelhaxm:

Shell
1
2
3
4
5
6
7
8
9
10
sc query intelhaxm
 
SERVICE_NAME: intelhaxm
        TYPE               : 1  KERNEL_DRIVER
        STATE              : 4  RUNNING
                                (STOPPABLE, NOT_PAUSABLE, IGNORES_SHUTDOWN)
        WIN32_EXIT_CODE    : 0  (0x0)
        SERVICE_EXIT_CODE  : 0  (0x0)
        CHECKPOINT         : 0x0
        WAIT_HINT          : 0x0

To create a list of all services used:

Shell
1
sc query type= service state= all > allservices.txt

You can use : start and stop to start and stop services.
The start option come with has one of the values auto, demand. or disabled.
Using administrator command shell you can see the RPC Services:

Shell
1
sc enumdepend rpcss

Posted in All, Commands, Windows 10 | Tagged: , , , . Leave a Comment

C# – First steps with C# and .NET – part 002 .

By admin | Published 11/09/2017

Today I will show you more about C# and the subject of this tutorial is: threads.
First you need to start a project into your folder. Let’s see my example:

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
C:\BackUP\Proiecte\CSharpNET>dotnet new console -o threads001
The template "Console Application" was created successfully.
 
C:\BackUP\Proiecte\CSharpNET>dotnet restore threads001
  Restoring packages for C:\BackUP\Proiecte\CSharpNET\threads001\threads001.csproj...
  Generating MSBuild file C:\BackUP\Proiecte\CSharpNET\threads001\obj\threads001.csproj.nuget.g.props.
  Generating MSBuild file C:\BackUP\Proiecte\CSharpNET\threads001\obj\threads001.csproj.nuget.g.targets.
  Restore completed in 10.55 sec for C:\BackUP\Proiecte\CSharpNET\threads001\threads001.csproj.
 
C:\BackUP\Proiecte\CSharpNET>cd threads001
 
C:\BackUP\Proiecte\CSharpNET\threads001>dotnet run
Hello World!

You can use notepad or any editor to edit the Program.cs:

C#
1
C:\BackUP\Proiecte\CSharpNET\threads001>notepad Program.cs

About the thread issue then you need to know is a very complex subject.
My example will show you how the thread works.
First you need to start the thread and then deal with the thread.
Two methods is used: Start and Join.
Start begins executing at the first line of the method and does not block the calling thread.
Join is a synchronization method that blocks the calling thread (that is, the thread that calls the method) until the thread whose Join method is called has completed.
I used three threads and this threads just start count first 5 sec , next 8 sec and the last is set to 10 sec.
Let’s see the example:

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
 
namespace threads001
{
  public class Program {
        static void StartMultipleThread() {
        //take time
        DateTime startTime = DateTime.Now;
        //parameterized thread nr. 1
        Thread Thread_nr_1 = new Thread(() => {
          int numberOfSeconds = 0;
          while (numberOfSeconds < 4)
          { Thread.Sleep(1000); numberOfSeconds++; }
          Console.WriteLine("Thread_nr_1 = 5 seconds");
          });
        //parameterized thread nr. 2
        Thread Thread_nr_2 = new Thread(() => {
          int numberOfSeconds = 0;
          while (numberOfSeconds < 7)
          { Thread.Sleep(1000); numberOfSeconds++; }
           Console.WriteLine("Thread_nr_2 = 8 seconds");
           });
        //parameterized thread nr. 3
        Thread Thread_nr_3 = new Thread(p => {
           int numberOfSeconds = 0;
           while (numberOfSeconds < Convert.ToInt32(p))
          { Thread.Sleep(1000); numberOfSeconds++; }
          Console.WriteLine("Thread_nr_3 = {0} seconds", numberOfSeconds);
          });
          //Start the threads nr. 1 , 2
          Thread_nr_1.Start();
          Thread_nr_2.Start();
          //Start thread nr. 3 with 10 sec
          Thread_nr_3.Start(10);
          //wait for Thread_nr_1 to fimish
          Thread_nr_1.Join();
          //wait for Thread_nr_2 to finish
          Thread_nr_2.Join();
          //wait for Thread_nr_3 to finish
          Thread_nr_3.Join();
          Console.WriteLine("Threads end in {0} secods", (DateTime.Now - startTime).TotalSeconds);
        }
        static void Main(string[] args)
        {
          StartMultipleThread();
          Console.WriteLine("Hello World!");
        }
    }
}

Each thread will write to the output and then will see the time used.
See the output of dotnet run command:

C#
1
2
3
4
5
6
C:\BackUP\Proiecte\CSharpNET\threads001>dotnet run
Thread_nr_1 = 5 seconds
Thread_nr_2 = 8 seconds
Thread_nr_3 = 10 seconds
Threads end in 10.0089403 secods
Hello World!

Posted in All, C#, Commands, Programming, Windows 10 | Tagged: , , , , , , , . Leave a Comment

C# – First steps with C# and .NET – part 001 .

By admin | Published 09/09/2017

First you need to take a look at Microsoft DotNET – Core website..
This website will be the start for any .NET and C# issue on any operating system Linux, Windows, Mac or Docker.
I used for this tutorial Windows OS and for Fedora distro you can take a look here.
First you need to

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
C:\BackUP\Proiecte\>dotnet new console -o appconsole001
The template "Console Application" was created successfully.
 
C:\BackUP\Proiecte\>cd appconsole001
 
C:\BackUP\Proiecte\appconsole001>dotnet --info
.NET Command Line Tools (1.1.0)
 
Product Information:
Version:            1.1.0
Commit SHA-1 hash:  d6f4336106
 
Runtime Environment:
OS Name:     Windows
OS Version:  10.0.15063
OS Platform: Windows
RID:         win10-x64
Base Path:   C:\Program Files\dotnet\sdk\1.1.0
 
C:\BackUP\Proiecte\appconsole001>dotnet --help
.NET Command Line Tools (1.1.0)
Usage: dotnet [host-options] [command] [arguments] [common-options]
 
Arguments:
  [command]             The command to execute
  [arguments]           Arguments to pass to the command
  [host-options]        Options specific to dotnet (host)
  [common-options]      Options common to all commands
 
Common options:
  -v|--verbose          Enable verbose output
  -h|--help             Show help
 
Host options (passed before the command):
  -d|--diagnostics      Enable diagnostic output
  --version             Display .NET CLI Version Number
  --info                Display .NET CLI Info
 
Commands:
  new           Initialize .NET projects.
  restore       Restore dependencies specified in the .NET project.
  build         Builds a .NET project.
  publish       Publishes a .NET project for deployment (including the runtime).
  run           Compiles and immediately executes a .NET project.
  test          Runs unit tests using the test runner specified in the project.
  pack          Creates a NuGet package.
  migrate       Migrates a project.json based project to a msbuild based project.
  clean         Clean build output(s).
  sln           Modify solution (SLN) files.
 
Project modification commands:
  add           Add items to the project
  remove        Remove items from the project
  list          List items in the project
 
Advanced Commands:
  nuget         Provides additional NuGet commands.
  msbuild       Runs Microsoft Build Engine (MSBuild).
  vstest        Runs Microsoft Test Execution Command Line Tool.
 
C:\BackUP\Proiecte\appconsole001>dotnet run
Hello World!

The result of Hello World! show us the console application works well.
This will run this program:

C#
1
2
3
4
5
6
7
8
9
10
11
12
using System;
 
namespace appconsole001
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

You can change the text Hello World or test something else.
If you got errors the you need to fix it with :

C#
1
2
3
C:\BackUP\Proiecte\dotnet restore appconsole001
  Restoring packages for C:\BackUP\Proiecte\appconsole001\appconsole001.csproj...
...

Posted in All, C#, Commands, Programming, Windows 10 | Tagged: , , , , , , , . Leave a Comment

JavaScript – Processing.js 2D library – part 003.

By admin | Published 08/09/2017

In this tutorial I will show you how to use images with processing.js.
You can use image from your computer or from url.
Let’s see one simple code example:

JavaScript
1
2
3
4
5
6
7
8
9
10
11
PImage img;
 
void setup() {
  background(10);
  size(300,300);
  img = loadImage("http://i.imgur.com/sb3qile.jpg");
}
 
void draw() {
  image(img, 0,0);
}

You can see same example on openprocessing web tool.
The openprocessing web tool allow you to use Processing.js and P5.js .

Posted in All, HTML 5, javascript, Programming | Tagged: , , , , , , . Leave a Comment