Intro

Over six years of studying, and working in technology Ive acquired over 600+ links. Losing these links to me would feel like the burning down of the Library of Alexandria. I use alot of them as references for programming and information security based work.

While scraping all these links I saw the word beginner become less frequent as we got closer to the present day, so I even found a fun way to add a visualization to this post.

Browser based Library of Alexandria

I cant stress the importance of reading enough, it will advance you more than you can imagine.

While writing a brief script to scrape all these links, which I will link shortly, I realized there are actually trends in these links.
We can actually use some python libraries and heuristics to identify these trends amongst the links.

1. Script I used to harvest my saved links from reddit, frequency data, and simultaneously create a word cloud
2. The organized and sorted links.

You can find the raw unsorted copy of all of the links here https://pastebin.com/raw/9K5sNfgK

Itll have a good deal of extraneous links that I found interesting, but Ive omitted them from this in order to keep it on topic of security.

Security is more than just knowledge of mechanism or inner-workings of code, its also a mindset. So I have some materials relating to social engineering, and overall thought process mixed in some places.

get_links && make_wordcloud

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

from __future__ import absolute_import, unicode_literals
import praw
import json 
from wordcloud import WordCloud, STOPWORDS 
import matplotlib.pyplot as plt 

class LinkSave(object):

	def __init__(self, mode=None):
		self.mode=mode

	def load_config(self, data):
		self.config = json.load(open(data))
		return self.config

	def auth_reddit(self):
		try:	
			self.reddit = praw.Reddit(
				client_id = self.config['reddit']['id'],
				client_secret = self.config['reddit']['secret'],
				user_agent = self.config['reddit']['user_agent'],
				username = self.config['reddit']['username'],
				password = self.config['reddit']['password']
			)
			self.me = self.reddit.user.me()
			return self.reddit
		except Exception as exc:
			print('{0} - Unable to auth to reddit, check your creds'.format(exc))	
			exit(0)

	def get_links(self):
		target = open("saved_links.txt", "w")
		self.words = ''
		for link in self.me.saved(limit=None):
			try:
				target.write('{0} -- {1}'.format(link.title, link.url))
				self.words = self.words + ' ' + link.title	
			except Exception as exc: 
				print('{0} - This exception handles saved comments '.format(exc))
		target.close()
		return self.words
		
	def make_cloud(self):
		stopwords = set(STOPWORDS) 
		stopwords.add("using")
		stopwords.add("programming")
		stopwords.add("post")
		stopwords.add("source")
		wordcloud = WordCloud(background_color="white", width=800, height=400, stopwords=stopwords).generate(self.words)
		plt.imshow(wordcloud, interpolation='bilinear')
		plt.axis("off")

		#render a second slightly different wordcloud
		wordcloud = WordCloud(background_color="white", stopwords=stopwords, max_font_size=40).generate(self.words)
		plt.figure()
		plt.imshow(wordcloud, interpolation="bilinear")
		plt.axis("off")
		plt.show()


if __name__ == '__main__':
	driver = LinkSave()
	driver.load_config('user_config.json')
	driver.auth_reddit()
	driver.get_links()
	driver.make_cloud()

''' user_config.json
{
 "reddit": {
   "id": "",
   "secret": "", 
   "user_agent": "",
   "username": "",
   "password": ""
	}
}
'''

Its a pretty succint script, I try to operate under the thought that if its clean enough its fairly self explanatory. Its a little personalized but you could easily edit it to do the same for you.

4 Step Linear flow:
Read in config -> Auth to reddit -> Scrape links into string and save to file -> generate word cloud

So what does this give us?

Personally I find that pretty neat, its a visualization of all Ive tried to hone in on over the years.The one that stands out most to me is Reverse Engineering, Ive been working on learning for a while. Its definitely one of the more challenging things Ive tried to wrap my mind around.

So Ive decided to throw it at the top of this list. Without delay, here is my best attempt at a sorted list.

Reverse Engineering && Malware

Bug Bounties

Penetration Testing (Exploit POCs, vulnerabilities)

Web Application Security

Computer Science && Algorithms

CTF

Web Development

Defensive Security && Sys Admin

Tech News

Saved Comments

TIL that Doom was so popular in 1995 that it was installed on more PCs than Windows 95. Bill Gates briefly considered buying ID software, but settled for getting a team at Microsoft to port the game to Win95. The team was led by Gabe Newell. > inverse square root
There is no obvious reason why this should work, and how Carmack or any of the previous users of this stunningly elegant hack came across the magic value 0x5f3759df appears to have been lost to history. Beyond3D tried to trace it back through the ages, but after going through Carmack, an x86 assembly hacker called Terje Matheson, NVIDIA and eventually Gary Tarolli who used it in his days at 3dfx, the trail went cold.
It’s a real pity, because finding that constant would have required someone to think in a completely different direction to everyone else, and be convinced enough that such a constant even existed to spend time narrowing it down.
Source: https://blog.dave.io/2011/10/0x5f3759df-true-magic-number/
From a web dev perspective, familiarize yourself with the OWASP rules to prevent it if you want to stay safe. XSS is one of the easiest things to find in the wild. Usually I can find it pretty quickly in a vulnerable site by just looking at the chrome network connections and seeing when requests are made with URL params, and see if changing those gets inserted into bad spots in the page - and that’s just reflected XSS, low hanging fruit. Some people just put URL parameters right into javascript, and something like ', 'z':alert('xss'), 'y': ' can work. Also, it’s not just quotes. alert(/XSS/) will execute too.
Just make sure you track the flow of user input, and never assume obfuscation or an extremely complex javascript file is enough to prevent people from realizing where input goes and how it might be processed. If you check for URL params that are prepended with debug_ and do something special with them, it’s going to be possible for attackers to find that and send their own input. And never assume that it being processed server side is enough to prevent people from finding a vulnerability.
Also, make sure you test with firefox. I’ve found that firefox has a lot of potential XSS that chrome fixes on its own. Chrome might prevent HTML tag injections like

WRITTEN BY

Anthony Laiuppa

DevSecOps Engineer