> NOTE: this site is live @`https://h4xr0x.cc
// original gamesense.pub crack (fake) gamesense.pub staff leaked the lua workshop, the gamesensical staff group dox'd the documentation which lead to it being // used in other cheat sources as api.gamesense.is = gcode solutions, legendware, nixware, dota2 company login. in directory you can find the build't in cheat // sources; the " crack" is leak of DLC ( downloadable content ) skeet is legendary because of the users who made that content. The cheat is an original paste, // the base buildt in cheat is by valve, extended by the community of modders, of which the hvh community gives crown to the rage content made by skeet users. // Which content can be used in this "crack" .
- GroupId:
gamesense.org.acme - ArtifactId:
gs - Version:
1.0.0-SNAPSHOT - Quarkus Version:
2.3.0.Final
-
you will need to install WSL2: https://ubuntu.com/tutorials/working-with-visual-studio-code-on-ubuntu-on-wsl2#1-overview
-
you will need Ubuntu 20.04: https://apps.microsoft.com/store/detail/ubuntu-20044-lts/9MTTCL66CPXJ
-
you will need to install NodeJS: https://ubuntu.com/tutorials/working-with-visual-studio-code-on-ubuntu-on-wsl2#5-install-nodejs-and-create-a-new-project
-
you will need to install sdkman:
curl -s "https://get.sdkman.io" | bash
-
you will need to then install
sdk install mavensdk instal spring-bootsudo apt-get install openjdk-11-jdksdk list javasdk install quarkus -
you will need to install: Visual Studio Code https://code.visualstudio.com/
-
you will need to install the Remote Development extention: https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.vscode-remote- extensionpack
-
you will need to install docker desktop: https://docs.docker.com/desktop/install/windows-install/
You can run your application in dev mode that enables live coding using:
./mvnw compile quarkus:devNOTE: Quarkus now ships with a Dev UI, which is available in dev mode only at http://localhost:8080/q/dev/.
The application can be packaged using:
./mvnw packageIt produces the quarkus-run.jar file in the target/quarkus-app/ directory.
Be aware that it’s not an über-jar as the dependencies are copied into the target/quarkus-app/lib/ directory.
The application is now runnable using java -jar target/quarkus-app/quarkus-run.jar.
If you want to build an über-jar, execute the following command:
./mvnw package -Dquarkus.package.type=uber-jarThe application, packaged as an über-jar, is now runnable using java -jar target/*-runner.jar.
You can create a native executable using:
./mvnw package -PnativeOr, if you don't have GraalVM installed, you can run the native executable build in a container using:
./mvnw package -Pnative -Dquarkus.native.container-build=trueYou can then execute your native executable with: ./target/gs-1.0.0-SNAPSHOT-runner
If you want to learn more about building native executables, please consult https://quarkus.io/guides/maven-tooling.html.
- YAML Configuration (guide): Use YAML to configure your Quarkus application
- Quarkus Extension for Spring Web API (guide): Use Spring Web annotations to create your REST services
Configure your application with YAML
The Quarkus application configuration is located in src/main/resources/application.yml.
Spring, the Quarkus way! Start your RESTful Web Services with a Spring Controller.
- Your static assets are located in
src/main/resources/META-INF/resources. - Configure your application in
src/main/resources/application.yml. - Quarkus now ships with a Dev UI (available in dev mode only)
- Play with the provided code located in
src/main/java:
Spring, the Quarkus way! Start your RESTful Web Services with a Spring Controller.
@Path: [/greeting](/greeting)
The Quarkus application configuration is located in src/main/resources/application.yml.
Spring, the Quarkus way! Start your RESTful Web Services with a Spring Controller.
- Your static assets are located in
src/main/resources/META-INF/resources. - Configure your application in
src/main/resources/application.yml. - Quarkus now ships with a Dev UI (available in dev mode only)
- Play with the provided code located in
src/main/java:
Spring, the Quarkus way! Start your RESTful Web Services with a Spring Controller.
@Path: [/greeting](/greeting)
ABOUT GAMESENSICAL GameSense
- Steam Group Administrators: NmChris and Wish
- Steam Group Moderators: Beta Users Only
- https://steamcommunity.com/groups/gamesensical
- https://gamesensical.gitbook.io/docs/
`@original: dev branch: https://github.com/h4xrOx/gamesense_docs | jessy-lua/docs#1
- Set up your enviorment
- updated and applied configurations
- you will need to install sdkman
$ curl -s "https://get.sdkman.io" | bash - you will need to then install
sdk install mavensdk instal spring-bootsudo apt-get install openjdk-11-jdksdk list javasdk install quarkus - you will need to install: Visual Studio Code https://code.visualstudio.com/
- you will need to install the Remote Development extention: https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.vscode-remote-extensionpack
- you will need to install docker desktop: https://docs.docker.com/desktop/install/windows-install/
sudo apt update
sudo apt upgrade
sudo apt-get install nodejs
sudo apt install npm
mkdir server/
cd server/
/ -- Now, open up your folder in Visual Studio Code, you can do this by typing: code. The first time you do this, it will trigger a download for the necessary dependencies:
-
install the remote ssh extention: vscode:extension/ms-vscode-remote.remote-ssh
-
follow the instructions here to set up SSH: https://code.visualstudio.com/docs/remote/ssh-tutorial
-
Aways, make sure that your current packages are up to date for security purposes.
sudo apt-get update
sudo apt-get upgrade
Now that all packages are up-to-date, run the “apt-get install” command in order to install OpenSSH.
sudo apt-get install openssh-server
ssh-keygen -t ed25519
From steps displayed on your console, you should see A configuration file is created in the /etc/ssh a folder named sshd_config. Symbolic links are created. One named sshd.service (your systemd service) and one in the multi-user target (to boot SSH when you log in).
sudo systemctl status sshd
netstat -tulpn | grep 22^
sudo apt-get install net-tools
sudo ufw allow ssh
sudo ufw status
sudo ufw enable
sudo ufw reset
sudo systemctl list-unit-files | grep enabled | grep ssh
If you have no results on your terminal, you should “enable” the service in order for it to be launched at boot time.
sudo systemctl enable ssh
sudo systemctl restart sshd
sudo systemctl status sshd
netstat -tulpn | grep
sudo ifconfig
ssh -p <port> <username>@<ip_address>
sudo systemctl stop sshd
sudo systemctl status sshd
Fork this repo and load the project in Visual Studio Code to create the Hello World Quarkus app, During this part of the tutorial we will be completing the following tasks:
-
Bootstrapping an application
-
Creating a JAX-RS endpoint
-
Injecting beans
-
Functional tests
-
Packaging of the application
- Roughly 15 minutes
- Visual Studio Code or another IDE
- JDK 11+ installed with JAVA_HOME configured appropriately
- Apache Maven 3.8.1+
- Optionally the Quarkus CLI if you want to use it & it: https://quarkus.io/guides/cli-tooling
open an integrated terminal in WSL Ubuntu from the /demo/gs/ directory. Type the following command and make sure to follow any instructions that may pop up due to dependancies to install sdkman:
curl -s "https://get.sdkman.io" | bash
open a new terminal in the same directory and type the following commands to finish the installation of sdkman:
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install maven sdk instal spring-boot sdk isntall java sdk install quarkus
/
mvn io.quarkus.platform:quarkus-maven-plugin:2.12.0.Final:create \
-DprojectGroupId=gamesense.org.acme \
-DprojectArtifactId=gs
/ -- If you have all dependancies, followed the instructions and your screen mirrors the image below, congradulations!! You are on you way to owning gamesense.pub!
-
an org.gamesense.acme.GreetingResource resource exposed on /hello
-
an associated unit test
-
a landing page that is accessible on http://localhost:8080 after starting the application
-
example Dockerfile files for both native and jvm modes in
src/main/docker -
the application configuration file
Once generated, look at the pom.xml. You will find the import of the Quarkus BOM, allowing you to omit the version of the different Quarkus dependencies. In addition, you can see the quarkus-maven-plugin responsible of the packaging of the application and also providing the development mode. I had you navigate to /demo/gs/ so you could this. I have already buildt the application in the main directory which has all dependancies and structure as a to guide you at any point you feel you need a reference.
During the project creation, the src/main/java/org/acme/GreetingResource.java file has been created with the following content:
package org.gamesense.acme;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
@Path("/hello")
public class GreetingResource {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String hello() {
return "Hello from RESTEasy Reactive";
}
}
./mvnw quarkus:dev
$ curl -w "\n" http://localhost:8080/hello
Hello from RESTEasy Reactive
NOTE: We are using
curl -w "\n"in this example to avoid your terminal printing a'%'or put both result and next command prompt on the same line. HitCTRL+Cto stop the application, or keep it running and enjoy the blazing fast hot-reload. Automatically add newline withcurl -w "\n"
-
Dependency injection in Quarkus is based on ArC which is a CDI-based dependency injection
-
ArC comes as a dependency of quarkus-resteasy-reactive so you already have it handy.
-
if you stopped the application, restart it with the following command:
./mvnw quarkus:dev
$ curl -w "\n" http://localhost:8080/hello/greeting/quarkus
hello quarkus
Normally you have to Modify the application and add a companion bean. Create the src/main/java/org/acme/GreetingService.java, navigate to it, here is where we can add import dependancies and features we want to add for testing or updates.
All that Gamesense.pub and cheat documentation. How does it work? How did I hack it? I'll tell you. RESTful API's use whats known as The OAS contract describes what the API does, it’s request parameters and response objects, all without any indication of code implementation. Web services defined with OAS can communicate with each other irrespective of the language they’re built in, since OAS is language agnostic and machine readable.
Swagger-core is the Java implementation of Swagger. Current version supports JAX-RS and plain servlets.
In this method, the Swagger/OAS contract is generated from an API based on the meta-data added against the various resources, methods and controllers. This meta-data will generate the contract, client-side code, and other artifacts during runtime. Typically, this meta-data will be in the form of code annotations. The tools trigger as the various methods and functions are called against their resources, and produces the OAS contract from the metadata defined in the API.
- Adding dependencies to your application
- Hooking Swagger Core to the Application
- Initialize the OAS Contract
The Swagger project uses maven for build and deployment of artifacts, available on Maven Central. Maven dependencies need JAX-RS coded API for Swagger Core to run. We hooked Swagger Core into the API with spring to get the dependancies. OAS definition can be initialized within an application during its runtime. The generated OAS definition will be in two files, defined in JSON and YAML. Take a look at swagger inspector https://swagger.io/tools/swagger- and insert the end point of the resource you want to have documented. You can then navigate to the right panel from the History section of Swagger Inspector, and click "Create API definition" to create the OAS definition.
./mvnw quarkus:dev
Open your browser to http://localhost:8080/greeting.
NOTE: quarkus:dev runs Quarkus in development mode. This enables live reload with background compilation, which means that when you modify your Java files and/or your resource files and refresh your browser, these changes will automatically take effect. This works too for resource files like the configuration property file. Refreshing the browser triggers a scan of the workspace, and if any changes are detected, the Java files are recompiled and the application is redeployed; your request is then serviced by the redeployed application. If there are any issues with compilation or deployment an error page will let you know. This will also listen for a debugger on port 5005. If you want to wait for the debugger to attach before running you can pass
-Dsuspendon the command line. If you don’t want the debugger at all you can use-Ddebug=false.
-
JDK 11+ installed with JAVA_HOME configured appropriately
-
Apache Maven 3.8.1+
-
A working container runtime (Docker or Podman) Related guide: https://quarkus.io/guides/podman
systemctl --user enable podman.socket --now
export DOCKER_HOST=unix:///run/user/${UID}/podman/podman.sock
NOTE: A working C development environment you'll need to download Visual Studio 2017 Visual C++ Build Tools: https://aka.ms/vs/15/release/vs_buildtools.exe
cmd /c 'call "C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC\Auxiliary\Build\vcvars64.bat" && mvn package -Pnative'
Mandrel or GraalVM recommended for building native executables that target Linux containerized environments. Install JDK & GraalVM using sdkman; if you havent got it already sdk java list will show all versions available.
Configure the runtime environment. Set GRAALVM_HOME environment variable to the GraalVM installation directory
export GRAALVM_HOME=$HOME/demo/gs/
NOTE: Java code that relies on preview features requires special attention. To produce a native executable, this means that the --enable-preview flag needs to be passed to the underlying native image invocation. You can do so by prepending the flag with -J and passing it as additional native build argument: -Dquarkus.native.additional-build-args=-J—enable-preview.
sudo apt-get install build-essential libz-dev zlib1g-dev
apt install g++ zlib1g-dev libfreetype6-dev
$ tar -xf mandrel-java17-linux-amd64-22.2.0.0-Final.tar.gz
$ export JAVA_HOME="$( pwd )/mandrel-java17-22.2.0.0-Final"
$ export GRAALVM_HOME="${JAVA_HOME}"
$ export PATH="${JAVA_HOME}/bin:${PATH}"
$ curl -O -J https://code.quarkus.io/d?e=io.quarkus:quarkus-resteasy-reactive
$ unzip code-with-quarkus.zip
$ cd code-with-quarkus/
$ ./mvnw package -Pnative
$ ./target/code-with-quarkus-1.0.0-SNAPSHOT-runner
Using the builder image on Windows with Docker Desktop (mind Resources-> File sharing settings so as Quarkus project directory is mountable).
powershell -c "Invoke-WebRequest -OutFile quarkus.zip -Uri https://code.quarkus.io/d?e=io.quarkus:quarkus-resteasy-reactive"
powershell -c "Expand-Archive -Path quarkus.zip -DestinationPath . -Force
cd code-with-quarkus
mvnw package -Pnative -Dquarkus.native.container-build=true -Dquarkus.native.builder-image=quay.io/quarkus/ubi-quarkus-mandrel:22.2.0.0-Final-java17
docker build -f src/main/docker/Dockerfile.native -t my-quarkus-mandrel-app .
docker run -i --rm -p 8080:8080 my-quarkus-mandrel-app
NOTE: It is also possible to use Podman for Windows with appending: -Dquarkus.native.container-runtime=podman..
Java code that relies on preview features requires special attention. To produce a native executable, this means that the --enable-preview flag needs to be passed to the underlying native image invocation. You can do so by prepending the flag with -J and passing it as additional native build argument: -Dquarkus.native.additional-build-args=-J—enable-preview.
One of the easiest ways to create container-image from a Quarkus application is to leverage one of the container-image extensions.
./mvnw quarkus:add-extension -Dextensions="io.quarkus:quarkus-smallrye-openapi"
mvnw package -Pnative -Dquarkus.native.container-build=true -Dquarkus.container-image.build=true
./mvnw package -Dnative
The command below is enough to generate a basic OpenAPI schema document from your REST Endpoints You will see the generated OpenAPI schema document launched in your browser with swagger ui:
curl http://localhost:8080/q/openapi
/ -- if successful in your connection; the server is running and you can now open launcher.exe and use the Gamesense cheat.
/ -- If unsuccessful join https://gamesense.cloud and get a FREE API key with the registration of your account. The project's home is there.
cRackCrAcKcrrAcKK h4xr0x#1337
![@dependabot[bot]](https://avatars.githubusercontent.com/in/29110?s=64&v=4){kind=small}