
# React Hooks

When we use React in a `class` base component, we have access to the [state](https://reactjs.org/docs/state-and-lifecycle.html) and [lifecycle method](https://reactjs.org/docs/state-and-lifecycle.html). This is not the case for `functional` component in React. To get the same capabilities as class base component, React introduced `hooks` .

## Hooks

Hooks are functions that allow a functional component to mimic or make use of lifecycle methods, state, and other React features as if we are using a class-based component.

Here are the list of available React hooks/functions:

- useState: Allows the use of component-level state in functional components.
- useEffect: Allows the use of lifecycle methods in functional components.
- useContext: Allows the use of the context system in functional components.
- useRef: Allows the use of refs.
- useReducer: Allows managing state using a reducer.

# State With Hooks

Lets take a look at `state` example in a class component.
Here in our class component we make use of the `state` and `setState` from `React.Component` to manage the state of our component.

```jsx
class Main extends React.Component {
	state = {
		count: 0,
	};
	increaseCounter() {
		this.setState({
			count: this.state.count + 1,
		});
	}
	render() {
		return (
			<div>
				<h1>clicks count: {this.state.count} </h1>
				<button onClick={this.increaseCounter.bind(this)}>+</button>
			</div>
		);
	}
}

ReactDOM.render(<Main />, document.querySelector("#root"));
```

In a functional component, because we are not extending the `React.Component`, we have no access to `state` property and `useState` method to manage our component. To overcome this problem, we use `useState` hook.

This hook take a `initial value` as an argument, and return an array with two elements.
The array contains a ` reference to the current value` of our state and a `reference to a setter function to set the value` for our state.

## useState

Here are the functional component example

```jsx
const { useState } = React; // import {useState} from 'React';
function Main() {
	// we initialize our state with number 0.
	// then the hook returns a property that we assigned named as `count`
	// and a set mehod that we named as `setCount`.
	const [count, setCount] = useState(0); //array destructuring
	function increaseCounter() {
		setCount(count + 1);
	}
	return (
		<div>
			<h1>clicks count: {count} </h1>
			<button onClick={increaseCounter}>+</button>
			<button onClick={() => setCount(0)}>Reset</button>
		</div>
	);
}
ReactDOM.render(<Main />, document.querySelector("#root"));
```

[full code and demo on codesandbox](https://codesandbox.io/s/react-usestate-hooks-example-81fnr2?file=/src/App.jsx)

In the example above, we use `useState()` with an initial value of `0`. The hook then returns two elements, which we set to variables called `count` and `setCount`. Instead of using `setState` to set the value of a state, we now use `setCount` or any name we give to it.

If we want to add another state, we simply add another line for that state like this:

```jsx
function Main(){
	const [count,setCount] = useState(0);
	const [isMax,setIsMax] = useState(false); //here we add another state
	...

}
```

The functional example above is equivalent to the class example below:

```jsx
class Main extends React.Component {
	state = {
		count: 0,
		isMax: false,
	};
}
```

### refresher on state

NOTE: Whenever we called `setState` or in this functional component example `setCount` to set our state. The whole component get `re-render` and get updated with the new value.

# Lifecycle with Hooks

Let's say we are fetching something from an external API. When we first present the page, we might want to fetch data from an API. It will take a little time for the data to get fetched, but when we get the data, we need to change the state of our component.

In class-based components, we can achieve this behavior using the `lifecycle methods`. The example below shows how we might use `componentDidMount` and `setState` methods in a class-based component to achieve this behavior. We also use the `componentDidUpdate` method because we implement a nextId button where we fetch the next data when we click on the button (think of this like a pagination example).

```jsx
class Main extends React.Component {
	state = {
		id: 1,
	};
	changeId(n) {
		this.setState({
			id: this.state.id + n,
		});
	}

	render() {
		return (
			<div>
				<h1>User: {this.state.id} </h1>
				<button onClick={() => this.changeId(-1)}> PrevUser </button>
				<button onClick={() => this.changeId(1)}> NextUser </button>
				<UserDetails id={this.state.id} />
			</div>
		);
	}
}

class UserDetails extends React.Component {
	state = {
		user: null,
	};

	async fetchUser() {
		const response = await (
			await fetch(`https://jsonplaceholder.typicode.com/users/${this.props.id}`)
		).json();
		this.setState({
			user: response,
		});
	}
	// this get called once when component mount.
	componentDidMount() {
		this.fetchUser();
	}

	/**
	we need to call fetchUser again when the id of parent component get updated.
	this will also get call when we our component get re-render 
	when we run setState.
	**/
	componentDidUpdate(prevProps) {
		/**
		componentDidUpdate have a param prevProps which we can use to reference
		previous props. We can use it to check if our id props change
		then we call fetchUser. This is to prevent infinite oops. 
		due to re-render when we use setState.
		**/
		if (prevProps.id !== this.props.id) {
			this.fetchUser();
			console.log("Getting User..!");
		}
	}

	render() {
		return (
			<div>
				{this.state.user && (
					<ul>
						<li>ID: {this.state.user.id}</li>
						<li>Name: {this.state.user.name}</li>
						<li>UserName: {this.state.user.username}</li>
						<li>Email: {this.state.user.email}</li>
					</ul>
				)}
			</div>
		);
	}
}

ReactDOM.render(<Main />, document.querySelector("#root"));
```

As we can see, we first use the `componentDidMount` method to initially make a request to the API.
Then we use the `setState` method to set the state and re-render our page with the newly fetched data. Without `componentDidUpdate`, if we click the NextId button, the UserDetails component will not fetch a user because we only call fetchUser once in `componentDidMount`.

Although `componentDidUpdate` is useful, it can cause problems such as infinite loops when we call `fetchUser()` because of the `setState` method in it. Thus, we use the `prevProps` value to conditionally call fetchUser.

## useEffect

We can achieve this same behavior in a functional component using the `useEffect` and `useState` hooks.

```jsx
const { useState, useEffect } = React; // import {useState,useEffect} from 'React';

function Main() {
	const [id, setId] = useState(1);
	const changeId = (n) => {
		setId(id + n);
	};
	return (
		<div>
			<h1>User: {id} </h1>
			<button onClick={() => changeId(-1)}> PrevUser </button>
			<button onClick={() => changeId(1)}> NextUser </button>
			<UserDetails id={id} />
		</div>
	);
}

function UserDetails(props) {
	const [user, setUser] = useState(null);

	const fetchUser = async () => {
		const response = await (
			await fetch(`https://jsonplaceholder.typicode.com/users/${props.id}`)
		).json();
		setUser(response);
	};

	//here as simple as that
	useEffect(() => {
		fetchUser();
	}, [props.id]);

	return (
		<div>
			{user && (
				<ul>
					<li>ID: {user.id}</li>
					<li>Name: {user.name}</li>
					<li>UserName: {user.username}</li>
					<li>Email: {user.email}</li>
				</ul>
			)}
		</div>
	);
}

ReactDOM.render(<Main />, document.querySelector("#root"));
```

[full code and demo on codesandbox](https://codesandbox.io/s/react-useeffect-hooks-example-b66ue5?file=/src/components/UserDetails.jsx)

Lets understand how `useEffect()` works. When we set our useEffect like this

```jsx
...
useEffect(()=>{
	fetchUser();
},[props.id]) // watching the value
...
```

The `useEffect` hooks take two arguments. A callback function and an array contains `values` to watch for.

During the first render it first call the callback containing `fetchUser()` function. then if the component get re-render it` watch` for any changes of values inside the array, and anytime the value change, it will re-run the callback.

This behaviors is just the same as we previously did using class base component when we check for `prevProps` values. Here we check for the `id` props value wether it is the same as the previous value, if the value changed then the callback is called.

Using `useEffect` is actually pretty clean if you ask me. We are able to combine both lifecycle method `componentDidMount` and `componentDidUpdate` into single hooks function.

### Note on useEffect

1. What array ?
   if we pass in an empty array to the hooks, the callback function will only run once.

   ```jsx
   useEffect(() => {
   	console.log("running once!");
   	fetchUser();
   }, []);
   ```

   if we pass in an `object` to the array, then the callback will get call in an infinite loop, event tho we are not changing the value of the object.

   ```jsx
   useEffect(() => {
   	console.log("running multiple times!");
   	fetchUser();
   }, [{ id: props.id }]);
   ```

   This effect is due to redux reducer, where everytime we create an object in javascript, different object were created in memory. Thus, everytime we re-render the page. A new object being pass to the array even if we not changing it's value.

   In short, anytime the value in the array get change, the callback will get called.

2. Async callback ?
   useEffect doesn't allowed for declaring async function as the callback function.

   ```jsx
   useEffect(
   	// this is not OK!
   	async () => {
   		const response = await (
   			await fetch(`https://jsonplaceholder.typicode.com/users/${props.id}`)
   		).json();
   		setUser(response);
   	},
   	[props.id]
   );
   ```

   If we run the above code, we will get an error

   ```
   Warning: useEffect must not return anything besides a function, which is used
   for clean-up.
   ```

   The callback functions must not return anything beside a function, if we declare as a async, it will return a promise.

   This is also `not` an OK behaviour

   ```jsx
   const fetchUser = async () => {
   	const response = await (
   		await fetch(`https://jsonplaceholder.typicode.com/users/${props.id}`)
   	).json();
   	setUser(response);
   };
   //this is not ok,
   useEffect(fetchUser, [props.id]);
   ```

   Instead we need to execute the async function inside a regular function like we previously did or like this.

   ```jsx
   useEffect(() => {
   	const fetchUser = async () => {
   		const response = await (
   			await fetch(`https://jsonplaceholder.typicode.com/users/${props.id}`)
   		).json();
   		setUser(response);
   	};
   	fetchUser();
   }, [props.id]);
   ```

## Create Our Own Custom Hooks

Using above example, we can make our code more cleaner and reusable by extracting some functionalities into separate functions. As you may known, hooks is just a function. So lets try refactor our code and create a separate hooks for fetching user.

```jsx
const { useState, useEffect } = React; // import {useState,useEffect} from 'React';

// here we define our custom hooks to fetch user.
// we detached the code from the UserDetails Component, so that
// it can be re-usable by another component.
// our UserDetails component end up becoming more clean.

function useUser(id) {
	const [user, setUser] = useState(null);
	//here as simple as that
	useEffect(() => {
		(async () => {
			const response = await (
				await fetch(`https://jsonplaceholder.typicode.com/users/${id}`)
			).json();
			setUser(response);
		})();
	}, [id]);

	//here we return fetched user
	return user;
}

function Main() {
	const [id, setId] = useState(1);
	const changeId = (n) => {
		setId(id + n);
	};
	return (
		<div>
			<h1>User: {id} </h1>
			<button onClick={() => changeId(-1)}> PrevUser </button>
			<button onClick={() => changeId(1)}> NextUser </button>
			<UserDetails id={id} />
		</div>
	);
}

// we detached all those useState, and useEffect hooks
// making it into a single hooks, thus making our component
// more clean.
function UserDetails(props) {
	// here we call our custom hooks
	const user = useUser(props.id);
	return (
		<div>
			{user && (
				<ul>
					<li>ID: {user.id}</li>
					<li>Name: {user.name}</li>
					<li>UserName: {user.username}</li>
					<li>Email: {user.email}</li>
				</ul>
			)}
		</div>
	);
}

ReactDOM.render(<Main />, document.querySelector("#root"));
```

[full code and demo on codesandbox](https://codesandbox.io/s/react-custom-hooks-example-5wykdk?file=/src/hooks/useUser.jsx)

# Ref with hooks

in react, ref system allows us the developer, to access DOM element just like we access it in vanilla js.

```js
const el = document.querySelector("#myElement");
```

To access the dom in a class component is to use the `React.createRef()` method and assign it to a variable. Then we reference that variable from the jsx element.

```jsx
class Main extends React.Component{
	constructor(props){
		super(props);
		this.myRef = React.createRef();
	}

	render(){
		return (
			<div>
				<input ref={this.myRef}>
			</div>
		)
	}
}
```

Let's use our UserDetails example, from `create custom hooks example`, and change it a little bit to make use of `ref`. For the sake of simplicity, we are only changing the Main component.

In a class base component it will look like this

```jsx
class Main extends React.Component {
	constructor(props) {
		super(props);
		this.state = {
			id: 1,
		};
		// here we declare our reference
		this.idsRef = React.createRef();
		this.ids = [...Array(10).keys()];
	}

	changeId() {
		// here we accessing the DOM value.
		const value = this.idsRef.current.value;
		if (value !== "") {
			this.setState({
				id: value,
			});
		}
	}

	render() {
		return (
			<div>
				<h1>User: {this.state.id}</h1>
				<label htmlFor="ids">Select id: </label>
				<select
					onChange={this.changeId.bind(this)}
					ref={this.idsRef} //we use ref
					name="ids"
					id="ids"
				>
					{this.ids.map((id) => (
						<option key={id + 1} value={id + 1}>
							{id + 1}
						</option>
					))}
				</select>
				<UserDetails id={this.state.id} />
			</div>
		);
	}
}
```

## useRef

For a functional component example, we use `useRef` hooks to implement the same behavior.

```jsx
const { useState, useRef } = React;
function Main() {
	const [id, setId] = useState(1);

	//here we declare our reference
	const idsRef = useRef("");
	const ids = [...Array(10).keys()];

	const changeId = () => {
		const value = idsRef.current.value;
		if (value !== "") {
			setId(value);
		}
	};

	return (
		<div>
			<h1>User: {id}</h1>
			<label htmlFor="ids">Select id: </label>
			<select
				onChange={changeId}
				ref={idsRef} // here we use ref
				name="ids"
				id="ids"
			>
				{ids.map((id) => (
					<option key={id + 1} value={id + 1}>
						{id + 1}
					</option>
				))}
			</select>
			<UserDetails id={id} />
		</div>
	);
}
```

As simple as that. [full code and demo on codesandbox](https://codesandbox.io/s/react-useref-hooks-example-oxnxjx?file=/src/App.jsx)

# End ?


React Hooks Basic


# Getting Started
- we are going to use SQLite as our SQL database, because it is easy, no need complicated installation process.
- Basic of it, is same as other SQL database (MySQL or PostgresSQL).
- we are using `Ubuntu 20.04` as our operating system.
- we are using `python3`.

# Check if SQLite installed
In our ubuntu machine, open a terminal and write `sqlite3`.
```bash
jun@b:~$ sqlite3
```
If our system could't not find any `sqlite3>` prompt, we might need to install it.
```bash
jun@b:~$ sudo apt install sqlite3
```
After the installation finished, run `sqlite3` command again and we will see something like this.

```bash
jun@b:~$ sqlite3

SQLite version 3.31.1 2020-01-27 19:55:54
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database.
sqlite> 
```
Noticed that, we got the `sqlite3>` prompt ? 
this means, we successfully installed it.

# SQLite basic
Let's us, test creating a new table for our SQLite database.
Using the prompt earlier, add the following SQL statement.
```sql
CREATE TABLE profiles ( name TEXT, sex TEXT, age INTEGER );
```
When we click `<ENTER>`, we might not see anything. 
```sql
sqlite> CREATE TABLE profiles ( name TEXT, sex TEXT, age INTEGER );
sqlite> 
```
To see if we successfully created our table. write `.tables` on the prompt to list our tables. In this case, we only got one table named `profiles`.
```sql
sqlite> .tables
profiles
```
We can describes our tables, to look at it's schemas using the `.schema` command in sqlite prompt. It will show back the `CREATE` schemas we use to create the table.
```sql
sqlite> .schema profiles
CREATE TABLE profiles ( name TEXT, sex TEXT, age INTEGER );
```
This table that we recently create are stored in a memory (RAM) and not persistence.
If we quite our sqlite program using `Ctrl+D`, all of our tables will be deleted.
To make it persistence, we need to save if to a file.

To make our data persistance, we can use `.open` command in sqlite, to open a db file,
and then run our `create table` command again to write to it.
- let's try open a db file named `profiles_db.db` and create our table
```sql
sqlite> .open profiles_db.db
sqlite> CREATE TABLE profiles ( name TEXT, sex TEXT, age INTEGER );
```
When we exited, our sqlite program, we can we a file was created in our current working directory.
```bash
jun@b:~$ ls
profiles_db.db
```
We can open our database, using the command `sqlite3 <our_db_name.db>` in terminal
```bash
jun@b:~$ sqlite3 profiles_db.db
```
or we can open it using `.open <our_db_name.db>` in sqlite prompt.
```bash
jun@b:~$ sqlite3
SQLite version 3.31.1 2020-01-27 19:55:54
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database.

sqlite> .open profiles_db.db
```
## Executes SQL statements from .sql file
Let's say we have a `insert-data.sql` file contains sql statements to insert data into our table and the file is located within our working directory. We can execute that file using `.read` command on sqlite prompt.
- let's say our `insert-data.sql` contains the following statements
```SQL
INSERT INTO profiles (name,sex,age) VALUES ("John","male",29);
INSERT INTO profiles (name,sex,age) VALUES ("Jane","female",24);
INSERT INTO profiles (name,sex,age) VALUES ("James","female",30);
```
- we can execute the statements like this, first we open previously create db, then run the `.read` command to read our `insert-data.sql` file. We can verified that data was inserted using sql `SELECT` statement.
```
sqlite> .open profiles_db.db
sqlite> .read insert-data.sql
sqlite> SELECT * FROM profiles;

John|male|29
Jane|female|24
James|female|30

sqlite> 
```

# Connecting SQL database with Python
Python had a [sqlite3 library](https://docs.python.org/3/library/sqlite3.html) that we can use to connect our python program with sqlite.

To use it, we simply import the library, and create a connection to our database file.
```py
import sqlite3

#if db file doesn't exist yet, it will create one for use.
connection = sqlite3.connect('profiles_db.db') 

connection.close()
```
To execute SQL statements, we will need to create a cursor, and use `cursor.execute()` function to execute our statement.
```py
import sqlite3

# we create connection
conn = sqlite3.connect("profiles_db.db")

# we create a cursor
cursor = conn.cursor()

# our SQL statement
stmt="SELECT * FROM profiles;"

# we execute our statement, and assign the results to an array
profileList = cursor.execute(stmt)

# Loop thru the list and print it out
for row in profileList:
    print(row)

conn.close() # we close connection
```
we can run it, and we see rows of profile get printed
```bash
jun@bin:~$ python3 profiles.py 
('John', 'male', 29)
('Jane', 'female', 24)
('James', 'female', 30)

```
- we can execute other various statements such as `CREATE`,`SELECT`,`INSERT` statements by simply write down the SQL statments and use `cursor.execute()` function to execute it.

```py
import sqlite3

# we create connection
conn = sqlite3.connect("profiles_db.db")

# we create a cursor
cursor = conn.cursor()

# user we want to add
firstUser = ("Moriaty","male",23)
# our SQL statement
insert_stmt="INSERT INTO profiles (name,sex,age) VALUES (?,?,?)"
select_stmt="SELECT * FROM profiles;"

# we execute insert statement, with the value as second arguments.
cursor.execute(insert_stmt,firstUser)

# we execute our statement, and assign the results to an array
profileList = cursor.execute(select_stmt)

# Loop thru the list and print it out
for row in profileList:
    print(row)

conn.close() # we close connection
```
Running the script above, we see that we successfully inserted a row into our table
```bash
jun@bin:~$ python3 profiles.py 
('John', 'male', 29)
('Jane', 'female', 24)
('James', 'female', 30)
('Moriaty', 'male', 23)

```

We can also insert multiple data by using the same statements but change `.execute` to `executemany`.
```py
import sqlite3

# we create connection
conn = sqlite3.connect("profiles_db.db")

# we create a cursor
cursor = conn.cursor()

# user we want to add
profiles = [
    ("Sherlock","male",23),
    ("Holmes","female",25)]

# our SQL statement
insert_stmt="INSERT INTO profiles (name,sex,age) VALUES (?,?,?)"
select_stmt="SELECT * FROM profiles;"

# we execute insert statement, with the value as second arguments.
cursor.executemany(insert_stmt,profiles)

# we execute our statement, and assign the results to an array
profileList = cursor.execute(select_stmt)

# Loop thru the list and print it out
for row in profileList:
    print(row)

conn.close() # we close connection
```

# More info
- for more information feel free to read the [official docs](https://docs.python.org/3/library/sqlite3.html) for `sqlite3` library in python.

SQLite with Python

## Why upgrade sudo ?
- recently in 2021, there is a new vulnerability for linux operating system that are caused by vulnerability in `sudo` commands.
- it is basically a vulnerability that enable attacker to gain `escalated privileges` to a root user on linux system.
- if an attacker can get access to your machine, by exploiting other user vulnerabilities, such as exploiting apache user in your webserver, they can gain root access if they know how to exploit this new sudo vulnerability.
- this exploit allows attacker to gain root access even though they are not in the sudoers list.
- I am still noobs in this field, so I will not explain it more.
- you can read more about it here [CVE-2021-3156](https://blog.qualys.com/vulnerabilities-research/2021/01/26/cve-2021-3156-heap-based-buffer-overflow-in-sudo-baron-samedit).


## Solution to this problem.
- for now the solution for this problem is basically upgrade your sudo to a new version.
- on [sudo website](https://www.sudo.ws/stable.html#1.9.5p2) there is a recent release that provided patch for this exploit.
- you can download it here [version 1.9.5p2](https://www.sudo.ws/dist/sudo-1.9.5p2.tar.gz)

    as you can see here, I am using the older version, which is vulnerable to this attack, my version is *1.8.31*

![sudo version 1.8.31](sudoversion.png)

## Install and upgrade it.
- the installation process is actually simple, like installing any other linux software from source.
- first download the file from [sudo website](https://sudo.ws) or click [here](https://www.sudo.ws/dist/sudo-1.9.5p2.tar.gz)
- after downloaded, extract the file using `tar` command.

    ``` bash
    tar -xzvf sudo-1.9.5p2.tar.gz
    ```
    - tar is an archiving utilities used to extract the file, 
    - `-x` param, is to extract
    - `-z` is to extract the gz or zip extension
    - `-v` is for verbose
    - `-f` is to specify the file which is **`sudo-1.9.5p2.tar.gz`**.

- it will extract the file into a folder called **sudo-1.9.5p2/**
- cd into that folder using 
    ``` bash
    cd sudo-1.9.5p2/
    ```
- then configure the installation by running **./configure** inside that folder.
    ``` bash
    ./configure
    ```
- after finished the configuration process, we just run make and install it.
    ``` bash
    make && sudo make install
    ```

- after the installation finished, we need to restart our session, to make use of the latest sudo version.
- example below shows, after i finished installed it

    ![results of sudo --version command showing that I've installed newer version of sudo](sudoinstalled.png)

sudo upgrade sudo


## Introduction

I've been using Easytether for quite some time to tether mobile data from my smartphone to my Linux computer. Usually, I just use Easytether-USB, but sometimes it is more convenient to use Bluetooth tethering so I don't need to constantly plug my phone into the computer using a USB cable.

If you are an Easytether user and a novice Linux user like me, you probably experience this every time you want to connect your phone via Bluetooth tethering:

You are required to find out the MAC address of your connected phone from the Bluetooth GUI interface:

You first need to open up a terminal and write "easytether-bluetooth <Your MAC address>".

I am too lazy to constantly write those commands, so I decided that maybe I could write a script for that...

## The procedure

To use Easytether-Bluetooth, I usually follow these steps:

1. Find my phone's Bluetooth MAC address.
2. Connect to it using easytether-bluetooth xx:xx:xx:xx:xx:xx, where xx:xx:xx:xx:xx:xx is my MAC address.
3. Sometimes Easytether is already running and I need to kill it and re-run that command.

## The script

I think my script is straightforward.

```bash
#!/bin/bash

# myMac=$(hcitool dev | grep -o "[[:xdigit:]:]\{11,17\}")
devMac=$(hcitool con | grep -o "[[:xdigit:]:]\{11,17\}")

echo "PC addr- $myMac"

function blt_connect {
    #check if easy-tether already running
    if grep -q "easytet+" <<< $(ps -aux) ; then
        echo "easytether already running in background"
        echo "Killing existing process"
        sudo kill $(pgrep easytet+)
        echo "reloading connection.."
        sudo easytether-bluetooth $devMac
    else
        echo "Trying to connnect"
        sudo easytether-bluetooth $devMac
        exit
    fi
}


if grep -q "[[:xdigit:]:]\{11,17\}" <<< "$devMac"; then
    echo "Connected Device- $devMac .."
    echo "connecting tether using bluetooth..."
    blt_connect
else
    echo "Bluetooth Device Not Connected"
fi
```

## The script breakdown

The first part involves finding my device's MAC address using hcitool.
hcitool is a Bluetooth configuration tool, and you can read more about it [here](https://linux.die.net/man/1/hcitool).

So, what I did was use hcitool con to display active connection info (my smartphone that is already connected to the PC) and use grep with regex to extract only the MAC address of my connected smartphone and store it in a variable $devMac.

```bash
    #!/bin/bash

    # myMac=$(hcitool dev | grep -o "[[:xdigit:]:]\{11,17\}")
    devMac=$(hcitool con | grep -o "[[:xdigit:]:]\{11,17\}")
```

Then I use grep and ps -aux to check if Easytether is previously running in the background. If true, I simply kill it and then run Easytether-Bluetooth.

```bash
    function blt_connect {
        #check if easy-tether already running
        if grep -q "easytet+" <<< $(ps -aux) ; then
            echo "easytether already running in background"
            echo "Killing existing process"
            sudo kill $(pgrep easytet+)
            echo "reloading connection.."
            sudo easytether-bluetooth $devMac
        else
            echo "Trying to connnect"
            sudo easytether-bluetooth $devMac
            exit
        fi
    }
```

The bottom part of the code simply checks if my phone's Bluetooth is actually connected to my PC before running easytether-bluetooth.

```bash
if grep -q "[[:xdigit:]:]\{11,17\}" <<< "$devMac"; then
    echo "Connected Device- $devMac .."
    echo "connecting tether using bluetooth..."
    blt_connect
else
    echo "Bluetooth Device Not Connected"
fi
```

The next part is just making the script executable and using it.

```sh
nurbxfit@jun~: chmod +x easytether-bluetooth.sh
```

This script may not be perfect, but it gets the job done.
I am not that experienced with Linux and writing bash scripts, but I learned a lot while researching how to write this script. I hope others can learn something from this too.


Easytether Bluetooth Script


## Intro
Back in February 2020, I joined RawSec 2020 minicon CTF competition held in KL under my lecturer' name (he's the one who attends the event, and I join the CTF remotely for fun). I joined this CTF challenges with my buddy [@CrystalCry97](https://github.com/amalsyahmi). 

We are able to solve quite number of challenges in that game,
but we didn't win because we both are still noobs or atleast I am noobs compared to other talented participants who joined that event. Back then I haven't got a chance to write a proper write-up on the challenges, but I still save some of the source code that I used to solve the challenges, and in this post I'll try to explain a bit about my solution and the source code.



## The Question
So this is a noobs level question.

![wargames0 questions](wargames0.png)

Out of my limited knowledge, I think there are a few ways to approach this problem, maybe we can use netcat to connect to the server to get and send the unsigned integers, or maybe write a bash script on top of that ? Because I am not that well knowledgable about linux command and bash scripting, I choose to approched this problem using python script.

## My Approach..
1. The first thing that I do is ping the domain name to get the ip address of the server (didn't remember if I ping it or use nmap to scan it, but I just want the IP address).
2. Then I start to write the script.
3. For the script, I am using python socket library to create a socket to communicate with the server and also make use of python struct library to pack and unpack the bytes send by the server. 
4. After received the 2 integers I add it together, send it back to the server and then wait for the flag 

the entire code is like this, (note that, this code is dirty and not great)
```python
import socket
import struct
s = socket.socket()
s.settimeout(2)
try:
    s.connect(target)
    mylist = []
    added = 0
    for x in range (0,2):
        header = struct.unpack('<I', s.recv(4))
        mylist.append(header)
    print mylist
    # add two numbers together
    for number in mylist:
        added += number[0]
        print number
        print "added:",added
    #send back the added number
    
    added = struct.pack('<I',added)
    print 'Sending:',added
    s.send(added)
    print "Wait for reply",
    reply = s.recv(1024)   
    print "reply", reply
    s.close()
    # print bytesNumber
    
except socket.error as error:
    print "Error Connecting:", error
```

this part of the code is just me importing the library and initialize the socket
I set the port number and the ip address of the target server to connect to.
```python
import socket
import struct
s = socket.socket()
s.settimeout(2)
port = 5345
target = (" 113.23.255.180",port)
```

then inside try statement, I try to connect to the server, I loops 2 times because of the 2 unsinged intergers being send by the server. I used struct.unpack() to unpack the bytes data, 
and '<I' parameter to unpack the little endian bytes into an interger
```python
try:
    s.connect(target)
    mylist = []
    added = 0
    for x in range (0,2):
        header = struct.unpack('<I', s.recv(4))
        mylist.append(header)
    print mylist
```

then, I basically just add those two integers in the list together and pack it back to send to the server and wait for the reply.

```python
    # add two numbers together
    for number in mylist:
        added += number[0]
        print number
        print "added:",added
    #send back the added number
    
    added = struct.pack('<I',added)
    print 'Sending:',added
    s.send(added)
    print "Wait for reply",
    reply = s.recv(1024)   
    print "reply", reply
    s.close()
    # print bytesNumber
```

and then the server reply  with the flag,
I used it to ssh into the next challenge
```
 User:level1 Pass:Adad!3fse5s
```

Well, I don't think that this is a best approach and obviously not the best code to tackle the problem,
but I just want to share how I did it. I hope this can be helpful to anyone that stumble across this kind of question. If there is easier and better solution, feel free to share it with me.

Hi, I am nurbxfit

Featured Posts

React Hooks Basic

SQLite with Python

sudo upgrade sudo

Easytether Bluetooth Script

wargames01 RawSec2020