
# 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 is basically a `functions` that allows a `functional component` to mimic or make use of the `lifecycle method` and `state`  and other as if we are using a class base component.

Here are the list of available react hooks/functions:
 - useState, allow to use `component-level state` in functional component.
 - useEffect, allow to use `lifecycle methods` in functional component.
 - useContext, allow to use `context` system in functional component.
 - useRef, allow to use `ref` .
 - useReducer, allow to store data tru 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 make use of the `useState()` giving the initial value of 0. The hook then return two elements which we set the first element to a variable called count and the second element to a variable called 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 otherline 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 external API. When we first presented with 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 base component we can achieve this behaviour using the `lifecycle methods` . 
Example below are how we might uses `componentDidMount` and `setState` methods in a class base component to achieve the behaviour. We also make use of `componentDidUpdate` method because we implement a nextId button where we fetch 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 cmponent 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  make use of the `componentDidMount` method to first making a request to the API. Then we use `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`.

Tho, `componentDidUpdate` is usefull, it can caused a problem  such as infinite loop when we call `fetchUser()` because of the `setState` method in it. Thus, we make use of `prevProps` value to conditionally call `fetchUser`.

## useEffect
We can achieve this same behaviour 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 behavious 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 seperate functions. As you may known, hooks is just a function. So lets try refactor our code and create a seperate 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 litle 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 behaviour.
```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 ?
In my next post, I will talk some more about context and redux, and I will be showing some example on how to use context in class and functional component.




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 times, to tether mobile data from my smartphone to my linux computer. Usually I just use the easytether-usb
but sometimes it is more handy to use the bluetooth tethering and I don't need to constantly plug in my phone to the computer using usb.

If you are an easytether user and a noob linux user like me, you probably experience this everytime you want to connect your phone via bluetooth tethering, 

you are requires to find out the Mac Address of your connected phone from the bluetooth GUI interface:
 > you first need to > open up terminal > write _"easytether-bluetooth <-Your Mac address->"_ . 

I am too lazy to constantly writing those command so I decided that maybe I can write a script for that ....

## The procedure
To use easytether-bluetooth, I usually follow these steps:
1. find my phone 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 already running and I need to kill it and re run that command.

## The script
I think my script is straight foward.

```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 me finding my device mac address using hcitool.
```hcitool``` is bluetooth configure connection tools and you can read more [here](https://linux.die.net/man/1/hcitool).

So, what I did was I use ```hcitool con``` to display active connection info (my smartphone that already connected to the pc)
and use grep regex to take only the mac address of my connected smartphone and store 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 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
    }
```

Bottom part of the code is just me simply checking if my phone 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
```
next part is just making the script executable and use it. 
```sh
nurbxfit@jun~: chmod +x easytether-bluetooth.sh
```

This is actually not a great script, but I am able to get the job done with it.

I am not that experience with linux and writing bash script, but I am able to learn a lot while researching on 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