DEV Community: Max Bridgland

Creating a Cleaner MacOS Workspace

Max Bridgland — Wed, 23 Dec 2020 23:13:31 +0000

The default macOS window management and desktop environment is great don't get me wrong. However, after using alternative window management solutions on Linux distros, I've craved a better solution. I've enjoyed ricing my Linux desktops for the past couple of years, and in doing so I've looked for similar tools I can use on macOS.

In this article I'll be walking you through how to get a setup resembling the photo above. The tools in use you see are:

yabai (Window Management)
skhd (Hotkeys for yabai, running commands, etc)
iTerm2 (Terminal Emulator)
pywal (Colorscheme Generator)
Übersicht (JSX Widgets on the desktop)
ncmpcpp and mopidy (Spotify music player on the command line)
dmenu-mac (Alternative Spotlight launcher)
gotop (htop alternative)

Getting Started

yabai

Yabai is a window manager that came from the creators older WM known as chunkwm. If you've ever used i3 or i3-gaps, it's extremely similar. Yabai works as a tiling window manager. There are a ton of customization options you can find on the GitHub Wiki.

To install follow the instructions found here. Make sure to disable SIP on your Mac!

If you'd like a similar setup to what I have, you can use the .yabairc file found here

skhd

skhd (simple hotkey daemon) is a hotkey manager for macOS. It was created by the same person as yabai and works hand in hand with it. Using skhd you can create keybinds to edit your workspace, launch applications, change system values, and more.

To install follow the instructions found here. If you'd like a config that already includes some yabai bindings, you can use the .skhdrc file found here

iTerm2

iTerm2 is a great macOS terminal emulator. It offers a massive amount of customization for your setup and even works with pywal. Pywal is a tool that will generate colorschemes from images and set your wallpaper w/ said image.

To install iTerm2, grab it here.

If you'd like to use my profile, simply open Profiles > Default > Colors: Under colorscheme select import > import this file and select it as your colorscheme.

To install pywal, run pip3 install pywal haishoku. I find that the haishoku backend generates the most favorable colorschemes.

ncmpcpp/mopidy

ncmpcpp is a command line based music player. You can see it in use in the two terminals on the top of the image. It has the ability to control mpd which I use mopidy to host. Mopidy is an mpd alternative that offers an MPD-like protocol and plugins. I use mopidy because it allows me to add Spotify to my mpd server! This means I get all spotify functionality through mpd.

First install mopidy, mopidy-mpd, and mopidy-spotify. To do so you can follow the steps here. Next follow the steps here to install ncmpcpp. Ignore the steps for installing mpd

I haven't changed much to those configs from the default so feel free to experiment on your own!

gotop

Gotop is an awesome go based process manager. It shows you a lot of information about your system and what processes are using what. You can install it by first installing Go and then running go get -u github.com/cjbassi/gotop

Other Customizations

You can also use custom CSS for Firefox and theme that. I made a tool to make the process easier. Read more about Foxify-CLI here.

Compressing Videos Easily on Windows w/ FFMPEG and Registry Files

Max Bridgland — Mon, 02 Nov 2020 23:59:53 +0000

I am always sharing clips and videos with my friends and often times the file size is ridiculously large to send over most social media (Discord, Twitter, Telegram, etc). To get around these massive file sizes, I use ffmpeg to compress the video. FFMPEG is a super powerful tool for all your media processing. It has a ton of libraries for handling different tasks involving visual and audio media.

Preface

Using ffmpeg we are able to compress videos down by ~10x. For example, if we have a 1 minute and 15 second clip that is 1080p 60fps @ 432Mb, we can use a simple one-line ffmpeg command to compress this video down to ~50Mb. This now allows us to send it on a lot of different platforms way easier.

Before Compression:

After Compression:

All the while, we lose little to no quality in the video. This is a great solution but it can be a serious hassle to have to open your terminal every time you want to compress these videos. I thought it would be easier to simply make a right-click menu item to quickly compress videos. I've tested it with m4v, mkv, and mp4 videos and it works flawlessly.

Normally you could just run:



ffmpeg -i INPUT_FILE.mp4 -vcodec h264 -acodec aac OUTPUT.mp4

but nobody wants to have to type this out every time. Since I already had an FFMPEG python compression script laying around I used that as the main program to be run.

Getting Setup

You need a couple of tools to start. First, get Python 3 (preferably above 3.5). Make sure you have Python3 installed to your PATH as well. See how here..

Next, install ffmpeg:



scoop install ffmpeg

Make sure your scoop shims are in your PATH! (C:\Users<YOU>
scoop\shims is the default path)

Now you're ready to start compressing!

Making our script and right-click registry file

compress.py

Starting out you can make a compress.py file and place it any where. I placed it in C:\Users\Max\ffmpeg-compress\compress.py. The contents of that file are as follows:



import sys
from subprocess import run, PIPE
from pathlib import Path

args = sys.argv[1:]
video_file = Path(' '.join(args))
run(['ffmpeg', '-i', video_file.name, '-vcodec', 'h264', '-acodec','aac', video_file.name.replace('.' + video_file.name.split('.')[-1], '-compressed.' + video_file.name.split('.')[-1])])

Going line by line:

1-3: Importing our modules. sys to get our arguments, run and PIPE from subprocess in order to call our command and get the output, and Path from pathlib to parse and clean up our path strings.

4: args is a list of arguments passed when calling the executable (this will be our filename)

5: video_file is a Path object with the args passed joined as a string

6: run([...]) is where we call the ffmpeg executable from Python and run our command to compress.

compress.bat

Next, you need to make a .bat file anywhere on your computer. I placed mine @ C:\Users\Max\compress.bat. The contents of that file are:



@echo OFF
SET subject=%*
for %%a in (%*) do set subject=%%a
python C:\\Users\\Max\\ffmpeg-compress\\compress.py %subject%

Going line by line:

1: @echo OFF disables the printing of each line in the batch script to the terminal. A standard in batch scripts.

2-3: Will set all of our arguments to a variable subject

4: Calls our python script with the video as our argument.

ffmpeg-compress.reg

Finally, we need to make a file called ffmpeg-compress.reg anywhere. We can use Notepad to do so. In this file, paste the following but replace the filepath for compress.bat with yours.



Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\*\shell\ffmpeg-compress]
@="Compress File w/ FFMPEG"

[HKEY_CLASSES_ROOT\*\shell\ffmpeg-compress\command]
@="\"C:\\Users\\Max\\compress.bat\" \"%1\""

Going section by section:

For [HKEY_CLASSES_ROOT\*\shell\ffmpeg-compress], we are setting the title of our right-click menu button.

For [HKEY_CLASSES_ROOT\*\shell\ffmpeg-compress\command], we are setting the actual command string we want the button to run when clicked.

Conclusion

Now when we right-click on a file, we have the option to Compress w/ FFMPEG

This will now allows us to easily compress videos without having to open the terminal.

A gist is available with the files used in this here:

Why are you using Python? Couldn't you do this in pure batch?

I suck with batch and I really don't like having to deal with weirdness passing args and parsing them. Python is just a more comfortable language for me. I'm also able to do string replacing and what not easier, and I already had the Python file

Getting Started with winfetch, A neofetch Alternative for Windows

Max Bridgland — Fri, 22 May 2020 22:37:50 +0000

Today I released a new tool called winfetch. I decided to make this as an excuse to learn the language Go and also because screenfetch/neofetch solutions on Windows in the past were extremely unreliable. I knew I would be limited as far as what I could display since we don't get as many cool libraries Unix systems get. I found a great module called ghw which allows you to query and obtain system/hardware information.

I thought it would be a great way to share it by writing a blog post about it. Winfetch is extremely simple to use thanks to how awesome Go is as a language and distribution platform. I was easily able to make my module distributed through GitHub so all you have to do to install it is run:



go get github.com/M4cs/winfetch

Once you do this you can add winfetch as a command to your $PROFILE.

You are able to customize what information you want displayed with the tool along with which colors and ASCII art is displayed. Below you can see two examples of configuration setups using winfetch:

As you can see you can easily add custom ASCII art. There is more information on the GitHub page which is available below:

GitHub Source and Readme - https://github.com/M4cs/winfetch

Simplifying "Login With Twitter" using Python and Flask.

Max Bridgland — Fri, 24 Apr 2020 20:39:16 +0000

Recently while working on a project I came across an issue with trying to implement Twitter Integrations into my Flask app. All of the guides on Google were breaking or just didn’t fit in with my application. I wanted a simple way to interface with Twitter’s OAuth1 API but everything was giving me errors.

NOTE: This guide assumes you have setup a Twitter Application and have your consumer keys and callback URLs set. If you do not know how to do this please refer to this guide.

Finally, I decided to try something myself, I looked into requests_oauthlib and realized it would be much easier to just use their Client class to generate signatures and implement with my Flask app. I couldn’t find any examples that were easy to understand or read as far as the code went so I wanted to share how I ended up implementing this into my application.

First the libraries I used in my implementation. flask is the library I’m using in order to create my main webserver and viewable routes. We don’t use much apart from the redirect function from it in this. flask_restful is the REST library I’m using in order to easily create a JSON based API. The endpoints we create in this are RESTful API Endpoints that inherit the Resource class from flask_restful. requests_oauthlib is the OAuth library I use in order to generate the OAuth headers to authenticate with Twitter’s API. We will also be using the requests library in order to make requests server side to Twitter.

First you need to setup a flask app. Lets make a folder called app first:

mkdir ./app
cd ./app

Now from within the app/ directory we will create a file called init.py :

# Let's import the Flask class from the flask library
from flask import Flask

# Let's import the Api class from the flask_restful library
from flask_restful import Api

# Let's import our OAuth library to setup
from requests_oauthlib.oauth1_auth import Client

# Create A Config To Store Values
config = {
    'twitter_consumer_key': 'ENTER TWITTER CONSUMER KEY',
    'twitter_consumer_secret': 'ENTER TWITTER CONSUMER SECRET'
}

# Initialize Our Flask App
app = Flask(__name__)

# Initialize Our RESTful API
api = Api(app)

# Initialize Our OAuth Client
oauth = Client(config['twitter_consumer_key'], client_secret=config['twitter_consumer_secret'])

This is all we need to do for now in the init.py file. Next we will start to create our endpoints for Twitter. This assumes you have setup a Twitter Application and you have your consumer keys.

Next we create our endpoint. For this we can just create a file called twitter.py or really whatever you’d like. Next we add:

# Import our functions and Resource class from flask_restful
from flask_restful import Resource, reqparse

# Import our functions from Flask
from flask import redirect

# Import our oauth object from our app
from app import oauth

# Import requests in order to make server sided requests
import requests

# We have to create our initial endpoint to login with twitter
class TwitterAuthenticate(Resource):
    # Here we are making it so this endpoint accepts GET requests
    def get(self):
        # We must generate our signed OAuth Headers
        uri, headers, body = oauth.sign('https://twitter.com/oauth/request_token')
        # We need to make a request to twitter with the OAuth parameters we just created
        res = requests.get(uri, headers=headers, data=body)
        # This returns a string with OAuth variables we need to parse
        res_split = res.text.split('&') # Splitting between the two params sent back
        oauth_token = res_split[0].split('=')[1] # Pulling our APPS OAuth token from the response.
        # Now we have to redirect to the login URL using our OAuth Token
        return redirect('https://api.twitter.com/oauth/authenticate?oauth_token=' + oauth_token, 302)

This is our authentication endpoint, when somebody attempts to hit this it will redirect them to the Twitter login page which will then send them to our Callback URL which you should have setup in your Twitter App’s dashboard.

Next we need to add the logic for handling our callback URL. We can add this to the same file as the TwitterAuthenticate class.

# We need to create a parser for that callback URL
def callback_parser():
    parser = reqparse.RequestParser()
    parser.add_argument('oauth_token')
    parser.add_argument('oauth_verifier')
    return parser

# Now we setup the Resource for the callback
class TwitterCallback(Resource):
    def get(self):
        parser = callback_parser()
        args = parser.parse_args() # Parse our args into a dict
        # We need to make a request to twitter with this callback OAuth token
        res = requests.post('https://api.twitter.com/oauth/access_token?oauth_token=' + args['oauth_token'] + '&oauth_verifier=' + args['oauth_verfier']])
        res_split = res.text.split('&')
        # Now we need to parse our oauth token and secret from the response
        oauth_token = res_split[0].split('=')[1]
        oauth_secret = res_split[1].split('=')[1]
        userid = res_split[2].split('=')[1]
        username = res_split[3].split('=')[1]
        # We now have access to the oauth token, oauth secret, userID, and username of the person who logged in. 
        # .... Do more code here
        # ....
        return redirect('http://somwhere.com", 302)

This TwitterCallback class will parse and handle the OAuth tokens in order to access the user’s account info. You can do whatever you want with this info whether that be storing it into a DB User Model or making requests with Tweepy!

The last step is adding these endpoints to your init.py file we created at the beginning! At the bottom of the file add this:

from app.twitter import TwitterAuthenticate, TwitterCallback

api.add_resource(TwitterAuthenticate, '/authenticate/twitter')
api.add_resource(TwitterCallback, '/callback/twitter') # This MUST match your Callback URL you set in the Twitter App Dashboard!!!

Our final twitter.py should look like this:

from flask_restful import Resource, reqparse
from flask import redirect
from app import oauth
import requests
class TwitterAuthenticate(Resource):
    def get(self):
        uri, headers, body = oauth.sign('[https://twitter.com/oauth/request_token'](https://twitter.com/oauth/request_token'))
        res = requests.get(uri, headers=headers, data=body)
        res_split = res.text.split('&') # Splitting between the two params sent back
        oauth_token = res_split[0].split('=')[1] # Pulling our APPS OAuth token from the response.
        return redirect('[https://api.twitter.com/oauth/authenticate?oauth_token='](https://api.twitter.com/oauth/authenticate?oauth_token=') + oauth_token, 302)

def callback_parser():
    parser = reqparse.RequestParser()
    parser.add_argument('oauth_token')
    parser.add_argument('oauth_verifier')
    return parser

class TwitterCallback(Resource):
    def get(self):
        parser = callback_parser()
        args = parser.parse_args() # Parse our args into a dict
        res = requests.post('[https://api.twitter.com/oauth/access_token?oauth_token='](https://api.twitter.com/oauth/access_token?oauth_token=') + args['oauth_token'] + '&oauth_verifier=' + args['oauth_verfier']])
        res_split = res.text.split('&')
        oauth_token = res_split[0].split('=')[1]
        oauth_secret = res_split[1].split('=')[1]
        userid = res_split[2].split('=')[1]
        username = res_split[3].split('=')[1]
        # ... Do Code Here
        return redirect('[http://somwhere.com](http://somwhere.com)", 302)

Our final init.py should look something like:

from flask import Flask
from flask_restful import Api
from requests_oauthlib.oauth1_auth import Client

config = {
    'twitter_consumer_key': 'ENTER TWITTER CONSUMER KEY',
    'twitter_consumer_secret': 'ENTER TWITTER CONSUMER SECRET'
}

app = Flask(__name__)
api = Api(app)
oauth = Client(config['twitter_consumer_key'], client_secret=config['twitter_consumer_secret'])

from app.twitter import TwitterAuthenticate, TwitterCallback

api.add_resource(TwitterAuthenticate, '/authenticate/twitter')
api.add_resource(TwitterCallback, '/callback/twitter')

I hope you find this guide helpful and have a fun time integrating with Twitter’s User API!

You can find a GitHub Gist here with the files shown above.

Follow me on Twitter and GitHub for more interesting programming stuff!

Making Slack More Fun with Slacky

Max Bridgland — Sat, 11 Jan 2020 11:54:02 +0000

Imagine being able to automate tasks, add custom notifications, custom commands, and add more fun things to do in Slack with your coworkers. Well I made it possible since there were no other Python selfbots Open Sourced on GitHub for Slack. I had always enjoyed using selfbots on Discord but since they were against ToS I had stopped. Slack on the other hand has no issues with these "custom integrations" and if anything, enable it. So today I present to you, Slacky.

Slacky is a personal token based approach to the common Slack bot. It allows for all RTM functionality a normal Slack bot would, but it uses your account to do it. It reads messages from your user in order to automate and make your messages more fun. It comes with a load of commands off the bat but also allows for easily adding plugin packs or your own custom Python commands.

Below you can see a preview of the tool:

It's also really easy to add your own plugins. A simple example plugin takes less than 30 lines! Here is an example:

from slacky import client, config, Prefixes, check_user
from slack.errors import SlackApiError

def custom_example(**payload):
    # Get Data from Payload
    data = payload['data']
    channel_id = data['channel'] # Get Channel ID
    user = data.get('user') # Get User
    timestamp = data['ts'] # Get msg Timestamp
    if check_user(user): # Check if User == You
        web_client = client # Init Client
        text = data.get('text') # Get Text
        # Check for Command Here
        if text:
            text_split = text.split(' ')
            cmd = text_split[0]
            if cmd == config['prefix'] + 'example':
                # Command has been triggered
                print(Prefixes.event + 'Ran Command: example')
                # Do your logic here and then update the message at the end below.
                try:
                    web_client.chat_update(
                        channel=channel_id,
                        ts=timestamp,
                        text="This command is an example custom command."
                    )
                except SlackApiError as e:
                    print(Prefixes.error + str(e))

There are a bunch of default commands as of the first release already. Below is a table of said commands:

Command	Description	Usage
heartbeat	Check if bot is up or not	~heartbeat
info	Get info about the bot	~info
ascii	Generate ASCII art from a phrase	~ascii msg
shift	CrEaTe ShIfT tExT lIkE tHiS	~shift phrase
subspace	Replace spaces with emojis	~subspace :emoji: msg
setprefix	Sets bot command prefix	~setprefix prefix
xkcd	Get Daily xkcd comic	~xkcd
delete	Delete X num of your msgs	~delete num_of_msgs
react	React to last sent message	~react :emoji:
reactrand	React to with random emoji	~reactrand
reactspam	Spam 23 Reactions (Notification Spam)	~randspam
howdoi	Find code snippets from stack overflow	~howdoi loop over list python
listener	Add or remove listeners	~listener add/delete phrase
listener list	List all listener words	~listener list
help	Display this message	~help

You can run this locally or with Docker to have it run in the background! The source code is available here and any plugin packs would be greatly appreciated! You will be featured in the README just make a Pull Request with any plugin packs you make.

JSONsty - Creating a Secure Cloud Storage Solution for JSON

Max Bridgland — Thu, 19 Dec 2019 04:14:53 +0000

One day I was sitting at work and my friend contacted me on Discord. He wanted an easy solution to host JSON data remotely for a Raspberry Pi project. He had used my service psty.io for a while and brought the idea to implement it into the service myself. I thought it was a great idea and hopped on it that night.

I decided I would write it in Python with Flask and using mongoDB as the main database. I wanted this to be secure, fast, and able to handle a lot of connections at once. I have been able to do so with this stack in the past and I was most comfortable with it so I gave it a shot.

The first part I wrote was the RESTful API. I knew it would be easiest with Flask since it's just JSON and that means no need to write a web front-end. This was done in a night and I had a very basic API for users. It simply allowed you to create JSON stores, edit them, delete them, and grab them. By the time this was done I showed a couple friends and they were concerned with the fact I was able to see all the data on the database. I wanted to look for a solution.

After that I decided it would be better to offer a panel to users so I decided I would just write an entire web front-end. These are very simple Jinja2 templated, server side rendered pages. I plan on making a React app once I get better with Javascript but since the main idea of this is the API I am not too worried since the frontend gets the job done. You can edit Account Settings, create stores, edit stores, and delete stores. The API is extremely simple and you are given an API key immediately when you signup!

I have been working with another developer the past couple weeks on an encryption/steganography technology called Pixcryption. We were working on adding the AES layer of security to it and I brought up JSONsty to him. He has been wanting to learn as much as possible so he took it as an opportunity to study Flask, MongoDB, Unit Testing, and more about AES.

We spent the past couple days working together on securing the system with AES OCB and Base64. Now it encrypts all the JSON data in the database and decrypts when the user requests their store. Each user has an object on the db and that controls which stores belong to them through ObjectIds which map a relationship between the collections.

Now JSONsty is ready for the public to start using in my eyes and I plan to make it even better over time. Psty.io has been doing well and I want to build it out into a family of software that provides tools for developers to make sharing and developing easier. Below you can find the source to JSONsty and you can also signup now here! We also would love any contributors who would like to harden the security or just make it a better service.

M4cs / jsonsty

☁️ Free Cloud JSON Storage Written in Python 🐍

Made with Python and Flask

JSONsty

What is JSONsty? JSONsty is a service provided by psty.io that allows you to store JSON data in the cloud for free using an extremely simple API or web panel frontend. The source code here includes everything running on the website as we speak. It should always be 1:1 up-to-date on the master branch compared to the website.

How Does It Work?

JSONsty is a Flask application that includes a REST API and dynamically rendered Website using the Jinja2 module. It interfaces and stores all data on a remote mongoDB cluster that acts as the master database. Users have an account which links the data, known as stores, on the database, and then link said store to the user.

When you create an account you receive an API Key which allows you to communicate with our API. The API allows you to create…

View on GitHub

Creating A Jailed Shell Webpage with Repl.it and an iFrame

Max Bridgland — Fri, 13 Dec 2019 16:01:08 +0000

How I Made A Jailed Shell Webpage with Repl.it

Recently I was inspired by repl.it's Jobs page. It uses their runtime to host an iframe of their shell that runs in the browser. This inspired me to make my own website follow suite and have a shell that users could use and navigate with commands rather than your traditional elemental webpage and UX. Big shoutout to Kognise for the help with everything!

I really liked this style since it made me think of all the fun I've had with CTFs and it gave me a perfect excuse to put one in my own website for fun. Repl.it makes this extremely easy by offering a bash environment off the bat which also includes a basic 18.04 Ubuntu bootstrap meaning it allows for Python and other stock scripting languages to be run. This means I can have a termporary Ubuntu environment running on my website without worrying about it being persistent or breaking a VPS that it's hosted on. Repl.it handles all of this with unlimited temporary containers for my website to be running concurrently. Meaning multiple people can be logged in and their changes won't effect one another!

It also just gives your website a certain hacky vibe which can be cool. The Repl project linked to this talk post has my bootstrap for a Jailed environment but I'll walk you through what I'm doing in it! The files that don't have logic just contain text which can be displayed using the cat command.

Inside main.sh we have the following:

chmod +x .pipes
rm -f ./main.sh
bash --rcfile .bashrc

What I'm doing here is giving a script permissions to run so people can run the command pipes on my webpage which produces an XP-alike pipes screensaver but in your terminal! Next we are removing the main.sh script to clean up the jailed environment. A lot of the custom files I use inside my jailed environment are hidden from the normal ls command which makes it less cluttered for the person visiting my site. Afterwards we run bash --rcfile .bashrc which runs a bash shell but with the file .bashrc as the source to load from, meaning it will run all of the commands inside .bashrc before allowing input from the user.

That brings us to .bashrc. I won't show you the entire file since most of it is already there by default you can pull the .bashrc script I have already inside the Repl. The custom parts of it are at the bottom as follows:

RED='\e[91m'
GREEN='\e[92m'
BROWN='\e[93m'
BLUE='\e[94m'
PURPLE='\e[95m'
CYAN='\e[96m'
GRAY='\e[97m'

export TERM=xterm-256color

export PATH="$PATH:$HOME"

PS1="\[${BLUE}\]guest\[${GRAY}\]@\[${PURPLE}\]maxbridgland.com\[${GRAY}\]:\[${PURPLE}\]\w\[${GRAY}\]$ \[${GRAY}\]"

alias pipes='./.pipes'
alias source='echo ""'
alias exit='echo "Ah! Ah! Ah!"'
alias mkdir='echo ""'
alias touch='echo ""'
alias rm='echo ""'
alias cp='echo ""'
alias mv='echo ""'
alias cd='echo "Use ls instead!"'
alias help='echo "Commands: ls, pipes, cat, motd"'
alias motd='cat .art'
alias alias='echo "Ah! Ah! Ah!"'
export bash='echo ""'
cat .art

The first variables being set are for colors codes in ANSI. This gives the PS1 which is the prompt before your input it's color. As you can see I set my user as guest and the host to maxbridgland.com to reflect my website. Setting TERM is to set the terminal base to render your colors in the terminal. This xterm-256 gives you all 256 R, G, and B values for colors. You would probably want to change this. What these commands are doing is removing the ability to run certain commands from the user. This gives it more of a jailed environment which goes along with the CTF I have included on my site. alias sets the variable afterwards to run whatever it is set to run. For most of these it just echo's nothing so it has no power, but to troll a bit you can see I've removed the exit command and replaced it with Ah! Ah! Ah! meaning you can stay as long as you wan't but you can never leave..

The last command is just displaying my .art file which holds the motd command's output. It has some ASCII art which was generated using THE BEST ASCII Text Generator Around. Here is what the .art file looks like:


 █     █░▓█████  ██▓     ▄████▄   ▒█████   ███▄ ▄███▓▓█████ 
▓█░ █ ░█░▓█   ▀ ▓██▒    ▒██▀ ▀█  ▒██▒  ██▒▓██▒▀█▀ ██▒▓█   ▀ 
▒█░ █ ░█ ▒███   ▒██░    ▒▓█    ▄ ▒██░  ██▒▓██    ▓██░▒███   
░█░ █ ░█ ▒▓█  ▄ ▒██░    ▒▓▓▄ ▄██▒▒██   ██░▒██    ▒██ ▒▓█  ▄ 
░░██▒██▓ ░▒████▒░██████▒▒ ▓███▀ ░░ ████▓▒░▒██▒   ░██▒░▒████▒
░ ▓░▒ ▒  ░░ ▒░ ░░ ▒░▓  ░░ ░▒ ▒  ░░ ▒░▒░▒░ ░ ▒░   ░  ░░░ ▒░ ░
  ▒ ░ ░   ░ ░  ░░ ░ ▒  ░  ░  ▒     ░ ▒ ▒░ ░  ░      ░ ░ ░  ░
  ░   ░     ░     ░ ░   ░        ░ ░ ░ ▒  ░      ░      ░   
    ░       ░  ░    ░  ░░ ░          ░ ░         ░      ░  ░
                        ░                                    

Take a look around, or head to https://n.maxbridgland.com

There may or may not also be a CTF somewhere here, but you have
to know me pretty well in order to get it ;)

Don't like my new site? Let me know on twitter! @maxbridgland

Run help to see some available commands... although it's not all of them

Just a simple message and some pretty ASCII text.

To host this I have a VPS that I've setup with my domain and an extremely simple HTML file and stylesheet. The setup for that can be found here. The index.html file is simple with just this:

<!DOCTYPE html>
<html>
  <head>
    <meta charset='utf-8'>
    <meta name='viewport' content='width=device-width'>
    <link rel='stylesheet' href='style.css' type='text/css'>
    <title>MySite</title>
  </head>
  <body>
    <iframe src='https://bashrepl.m4cs.repl.run'></iframe>
  </body>
</html>

An iFrame pointing to my repl.run instance and filled up in the webpage by my stylesheet here:

iframe {
  border: none;
  width: 100%;
  height: 100%;
}

body {
  margin: 0;
  height: 100vh;
}

Super simple!

As you can see, setting up a Repl.it Runtime Environment and Customizing it to make your own website-thats-a-shell is easy! It's also a great way to learn your way around repl and see the capabilities of what they offer. The fact we get free containers like this is crazy!

The CTF is in my website currently and only one person has got it with some hints. If you can get it, you'll know what to do! Good luck!

Creating a REST API with MongoDB and the Falcon Framework Python

Max Bridgland — Tue, 05 Nov 2019 05:05:03 +0000

Recently I started working with the Falcon Framework to make an API for a URL shortening site. A friend of mine showed me the framework and I decided to give it a try. It's a bit of a learning curve from other common frameworks like Django or Flask, but once you get the hang of it, it's super easy to work with.
In this article I'll go over the basic setup of a Falcon REST API with MongoDB support. This is the first part to a multipart series on how to build a complete Dart, Falcon, MongoDB webapp.

To start, we will want a file structure like so:

- app/
|- controllers/
|- resources/
|- models/
|- __init__.py
|- settings.py
- app.py

All of our logic will live inside of the app/ folder. Inside this app folder we have a controllers/ folder which will hold the helper functions and logic for communicating with our database and performing internal functions, theresources/ folder which will hold all of our routes, and themodels/ folder will hold the logic for setting up our models in our database. The settings.py file contains our configuration for the application where we will store our variables for credentials and what not. Make sure you include an init.py file in every folder insideapp/. The top level init.py file will include our base setup and definition of our application. Let's start with getting the dependencies needed to run our application.

Make sure you have mongoDB installed on your system, or have a database hosted on a server. If you have it hosted on your server then the HOST constant in our settings.py folder will be the IP of that address. If you have the database hosted locally for development purposes you will use localhost as the HOST constant.

You can check if you have mongoDB installed by running:

mongod --version

If you see something like:

root@mainbox:~# mongod --version
db version v3.2.22

then you should be set. There will probably be more information about your environment but the first line is all that matters. For this I'll be using mongoDB version 3.2.22.

To get setup with our python dependencies we will start by creating a virtualenv:

pip3 install virtualenv
virtualenv .venv
source .venv/bin/activate # or .venv/Scripts/activate on Windows
pip install falcon falcon-jsonify mongoengine

If you are on Unix or Linux you will also need to install a webserver to run the application. You can use uwsgi or gunicorn. If you are on Windows you will want to use the waitress module.

To install uwsgi or gunicorn:

pip install uwsgi
pip install gunicorn
To install waitress and hupper for hot reloads:
pip install waitress hupper

Waitress doesn't include a hot-reload option by default like uwsgi or gunicorn so you must use hupper in order to have this feature (it makes development a lot easier but it is not necessary).
Now that we have all of our dependencies installed we can start configuring our application. Open up our settings.py file inside app/. Set it up like the following snippet replacing your information:

import os
import flask_jsonfiy
dbcfg = {
    'host': 'localhost', # or external server address
    'port': 27017,
    'username': os.environ.get('MONGO_USER'),
    'password': os.environ.get('MONGO_PASS'),
}
middleware = [
    falcon_jsonify.Middleware(help_messages=True),
]

This is all we need for now. If you end up using middleware or need to configure other options do it inside this file and import it from your other modules.
Now we can setup our core init.py file inside the app/ folder. Set it up like so:

import falcon
import mongoengine as mongo
from app.settings import middleware
app = falcon.API(middleware=middleware)
db = mongo.connect(
    'development', # This will be the name of your database
    host=dbcfg['host'],
    port=dbcfg['port'],
    username=dbcfg['username'],
    password=dbcfg['password']
)

For now this all we need until we add an endpoint in resources/. Now we can setup our basic User model for the website. This is the only model we will be working in this part of the tutorial. To start create a file inside models/ called notes_model.py. You should setup your file like so:

from mongoengine import *
import datetime
class NoteModel(Document):
   title = StringField(max_length=200, required=True)
   body = StringField(max_length=32, required=True, unique=True)

There isn't much to the model for now but you'll add to this later. Now we can move onto setting up our basic register endpoint. Open up the resources/ folder and add a file named notes.py. Inside of this file we will add the logic to setup our handlers and responses. You should also make a file named notes.py inside the controllers/ folder. These files will work together. Setup the resources/notes.py file up like so:

import falcon
from app.controllers.notes import NotesController
from app import db
from app.models.notes_model import NoteModel
class GetNotes(object):
    def on_get(self, req, resp, id):
        resp.status = falcon.HTTP_200
        notes = []
        notes_obj = NoteModel.objects(title=title)
        for object in notes_obj:
            notes.append(object)
        resp.json = {
            'notes': notes
        }
class UploadNotes(object):
    def on_post(self, req, resp):
        title = resp.get_json('title', dtype=str)
        body = resp.get_json('body', dtype=str)
        notes_obj = NoteModel(
            title=title, body=body
        )
        notes_obj.save()
        resp.status = falcon.HTTP_201
        resp.json = {
            'message': 'Your Note Has Been Posted!',
            'status': 200,
            'successful': True
        }

Now that we have our resource setup we can open our core init.py file in the app/ folder. You will want to add these lines to the bottom:
from app.resources.notes import *
app.add_route('/notes/', UploadNotes)
app.add_route('/notes/{}', GetNotes)
Unlike other frameworks you aren't going to be returning anything. This is all we need for a basic REST API. We can now communicate with our mongoDB database by sending requests to our server.

Now we can start our webapp:

# With Gunicorn:
gunicorn -p 8000 --reload app:app
# With uWSGI:
uwsgi --http :9090 --wsgi-file app.py
With Waitress and Hupper:
hupper -m waitress --port=8000 app:app

Your server should be running on http://localhost:8000/ now. You should try to post something to the /notes/ endpoint which will allow you to add a note.