")
+def redirect_(hash_):
+ if hash_ not in mapping:
+ return "URL Not Found", 404
+ return redirect(mapping[hash_])
+
+
+if __name__ == "__main__":
+ app.run(debug=True)
+
+"""
+OUTPUT:
+
+
+===> SHORTENING
+
+$ curl localhost:5000/shorten -H "content-type: application/json" --data '{"url":"https://linkedin.com"}'
+Shortened: r/a62a4
+
+
+===> REDIRECTING, notice the response code 302 and the location header
+
+$ curl localhost:5000/r/a62a4 -v
+* Uses proxy env variable NO_PROXY == '127.0.0.1'
+* Trying ::1...
+* TCP_NODELAY set
+* Connection failed
+* connect to ::1 port 5000 failed: Connection refused
+* Trying 127.0.0.1...
+* TCP_NODELAY set
+* Connected to localhost (127.0.0.1) port 5000 (#0)
+> GET /r/a62a4 HTTP/1.1
+> Host: localhost:5000
+> User-Agent: curl/7.64.1
+> Accept: */*
+>
+* HTTP 1.0, assume close after body
+< HTTP/1.0 302 FOUND
+< Content-Type: text/html; charset=utf-8
+< Content-Length: 247
+< Location: https://linkedin.com
+< Server: Werkzeug/0.15.4 Python/3.7.7
+< Date: Tue, 27 Oct 2020 09:37:12 GMT
+<
+
+Redirecting...
+Redirecting...
+* Closing connection 0
+You should be redirected automatically to target URL: https://linkedin.com. If not click the link.
+"""
+```
diff --git a/courses/level101/security/conclusion.md b/courses/level101/security/conclusion.md
new file mode 100644
index 0000000..8eeceea
--- /dev/null
+++ b/courses/level101/security/conclusion.md
@@ -0,0 +1,25 @@
+# Conclusion
+
+Now that you have completed this course on Security you are now aware of the possible security threats to computer systems & networks. Not only that, but you are now better able to protect your systems as well as recommend security measures to others.
+
+This course provides fundamental everyday knowledge on security domain which will also help you keep security at the top of your priority.
+
+## Other Resources
+
+Some books that would be a great resource
+
+- Holistic Info-Sec for Web Developers - Free and downloadable book series with very broad and deep coverage of what Web Developers and DevOps Engineers need to know in order to create robust, reliable, maintainable and secure software, networks and other, that are delivered continuously, on time, with no nasty surprises
+- Docker Security - Quick Reference: For DevOps Engineers - A book on understanding the Docker security defaults, how to improve them (theory and practical), along with many tools and techniques.
+- How to Hack Like a Legend - A hacker’s tale breaking into a secretive offshore company, Sparc Flow, 2018
+- How to Investigate Like a Rockstar - Live a real crisis to master the secrets of forensic analysis, Sparc Flow, 2017
+- Real World Cryptography - This early-access book teaches you applied cryptographic techniques to understand and apply security at every level of your systems and applications.
+- AWS Security - This early-access book covers commong AWS security issues and best practices for access policies, data protection, auditing, continuous monitoring, and incident response.
+
+## Post Training asks/ Further Reading
+
+- CTF Events like :
+- Penetration Testing :
+- Threat Intelligence :
+- Threat Detection & Hunting :
+- Web Security:
+- Building Secure and Reliable Systems :
diff --git a/courses/level101/security/fundamentals.md b/courses/level101/security/fundamentals.md
new file mode 100644
index 0000000..5c82e67
--- /dev/null
+++ b/courses/level101/security/fundamentals.md
@@ -0,0 +1,334 @@
+# Part I: Fundamentals
+
+## Introduction to Security Overview for SRE
+
+- If you look closely, both Site Reliability Engineering and Security Engineering are concerned with keeping a system usable.
+ - Issues like broken releases, capacity shortages, and misconfigurations can make a system unusable (at least temporarily).
+ - Security or privacy incidents that break the trust of users also undermine the usefulness of a system.
+ - Consequently, system security should be top of mind for SREs.
+
+
+
+- SREs should be involved in both significant design discussions and actual system changes.
+ - They have quite a big role in System design & hence are quite sometimes the first line of defence.
+ - SRE’s help in preventing bad design & implementations which can affect the overall security of the infrastructure.
+- Successfully designing, implementing, and maintaining systems requires a commitment to **the full system lifecycle**. This commitment is possible only when security and reliability are central elements in the architecture of systems.
+- Core Pillars of Information Security :
+ - **Confidentiality** – only allow access to data for which the user is permitted
+ - **Integrity** – ensure data is not tampered or altered by unauthorized users
+ - **Availability** – ensure systems and data are available to authorized users when they need it
+
+- Thinking like a Security Engineer
+ - When starting a new application or re-factoring an existing application, you should consider each functional feature, and consider:
+ - Is the process surrounding this feature as safe as possible? In other words, is this a flawed process?
+ - If I were evil, how would I abuse this feature? Or more specifically failing to address how a feature can be abused can cause design flaws.
+ - Is the feature required to be on by default? If so, are there limits or options that could help reduce the risk from this feature?
+
+- Security Principles By OWASP (Open Web Application Security Project)
+ - Minimize attack surface area :
+ - Every feature that is added to an application adds a certain amount of risk to the overall application. The aim of secure development is to reduce the overall risk by reducing the attack surface area.
+ - For example, a web application implements online help with a search function. The search function may be vulnerable to SQL injection attacks. If the help feature was limited to authorized users, the attack likelihood is reduced. If the help feature’s search function was gated through centralized data validation routines, the ability to perform SQL injection is dramatically reduced. However, if the help feature was re-written to eliminate the search function (through a better user interface, for example), this almost eliminates the attack surface area, even if the help feature was available to the Internet at large.
+ - Establish secure defaults:
+ - There are many ways to deliver an “out of the box” experience for users. However, by default, the experience should be secure, and it should be up to the user to reduce their security – if they are allowed.
+ - For example, by default, password ageing and complexity should be enabled. Users might be allowed to turn these two features off to simplify their use of the application and increase their risk.
+ - Default Passwords of routers, IoT devices should be changed
+ - Principle of Least privilege
+ - The principle of least privilege recommends that accounts have the least amount of privilege required to perform their business processes. This encompasses user rights, resource permissions such as CPU limits, memory, network, and file system permissions.
+ - For example, if a middleware server only requires access to the network, read access to a database table, and the ability to write to a log, this describes all the permissions that should be granted. Under no circumstances should the middleware be granted administrative privileges.
+ - Principle of Defense in depth
+ - The principle of defence in depth suggests that where one control would be reasonable, more controls that approach risks in different fashions are better. Controls, when used in depth, can make severe vulnerabilities extraordinarily difficult to exploit and thus unlikely to occur.
+ - With secure coding, this may take the form of tier-based validation, centralized auditing controls, and requiring users to be logged on all pages.
+ - For example, a flawed administrative interface is unlikely to be vulnerable to an anonymous attack if it correctly gates access to production management networks, checks for administrative user authorization, and logs all access.
+ - Fail securely
+ - Applications regularly fail to process transactions for many reasons. How they fail can determine if an application is secure or not.
+
+ ```
+
+ is_admin = true;
+ try {
+ code_which_may_faile();
+ is_admin = is_user_assigned_role("Adminstrator");
+ }
+ catch (Exception err) {
+ log.error(err.toString());
+ }
+
+ ```
+ - If either codeWhichMayFail() or isUserInRole fails or throws an exception, the user is an admin by default. This is obviously a security risk.
+
+ - Don’t trust services
+ - Many organizations utilize the processing capabilities of third-party partners, who more than likely have different security policies and posture than you. It is unlikely that you can influence or control any external third party, whether they are home users or major suppliers or partners.
+ - Therefore, the implicit trust of externally run systems is not warranted. All external systems should be treated similarly.
+ - For example, a loyalty program provider provides data that is used by Internet Banking, providing the number of reward points and a small list of potential redemption items. However, the data should be checked to ensure that it is safe to display to end-users and that the reward points are a positive number, and not improbably large.
+ - Separation of duties
+ - The key to fraud control is the separation of duties. For example, someone who requests a computer cannot also sign for it, nor should they directly receive the computer. This prevents the user from requesting many computers and claiming they never arrived.
+ - Certain roles have different levels of trust than normal users. In particular, administrators are different from normal users. In general, administrators should not be users of the application.
+ - For example, an administrator should be able to turn the system on or off, set password policy but shouldn’t be able to log on to the storefront as a super privileged user, such as being able to “buy” goods on behalf of other users.
+ - Avoid security by obscurity
+ - Security through obscurity is a weak security control, and nearly always fails when it is the only control. This is not to say that keeping secrets is a bad idea, it simply means that the security of systems should not be reliant upon keeping details hidden.
+ - For example, the security of an application should not rely upon knowledge of the source code being kept secret. The security should rely upon many other factors, including reasonable password policies, defence in depth, business transaction limits, solid network architecture, and fraud, and audit controls.
+ - A practical example is Linux. Linux’s source code is widely available, and yet when properly secured, Linux is a secure and robust operating system.
+ - Keep security simple
+ - Attack surface area and simplicity go hand in hand. Certain software engineering practices prefer overly complex approaches to what would otherwise be a relatively straightforward and simple design.
+ - Developers should avoid the use of double negatives and complex architectures when a simpler approach would be faster and simpler.
+ - For example, although it might be fashionable to have a slew of singleton entity beans running on a separate middleware server, it is more secure and faster to simply use global variables with an appropriate mutex mechanism to protect against race conditions.
+ - Fix security issues correctly
+ - Once a security issue has been identified, it is important to develop a test for it and to understand the root cause of the issue. When design patterns are used, the security issue is likely widespread amongst all codebases, so developing the right fix without introducing regressions is essential.
+ - For example, a user has found that they can see another user’s balance by adjusting their cookie. The fix seems to be relatively straightforward, but as the cookie handling code is shared among all applications, a change to just one application will trickle through to all other applications. The fix must, therefore, be tested on all affected applications.
+ - Reliability & Security
+ - Reliability and security are both crucial components of a truly trustworthy system, but building systems that are both reliable and secure is difficult. While the requirements for reliability and security share many common properties, they also require different design considerations. It is easy to miss the subtle interplay between reliability and security that can cause unexpected outcomes
+ - Ex: A password management application failure was triggered by a reliability problem i.e poor load-balancing and load-shedding strategies and its recovery were later complicated by multiple measures (HSM mechanism which needs to be plugged into server racks, which works as an authentication & the HSM token supposedly locked inside a case.. & the problem can be further elongated ) designed to increase the security of the system.
+
+---
+
+## Authentication vs Authorization
+
+- **Authentication** is the act of validating that users are who they claim to be. Passwords are the most common authentication factor—if a user enters the correct password, the system assumes the identity is valid and grants access.
+ - Other technologies such as One-Time Pins, authentication apps, and even biometrics can also be used to authenticate identity. In some instances, systems require the successful verification of more than one factor before granting access. This multi-factor authentication (MFA) requirement is often deployed to increase security beyond what passwords alone can provide.
+- **Authorization** in system security is the process of giving the user permission to access a specific resource or function. This term is often used interchangeably with access control or client privilege. Giving someone permission to download a particular file on a server or providing individual users with administrative access to an application are good examples. In secure environments, authorization must always follow authentication, users should first prove that their identities are genuine before an organization’s administrators grant them access to the requested resources.
+
+### Common authentication flow (local authentication)
+
+- The user registers using an identifier like username/email/mobile
+- The application stores user credentials in the database
+- The application sends a verification email/message to validate the registration
+- Post successful registration, the user enters credentials for logging in
+- On successful authentication, the user is allowed access to specific resources
+
+### OpenID/OAuth
+
+***OpenID*** is an authentication protocol that allows us to authenticate users without using a local auth system. In such a scenario, a user has to be registered with an OpenID Provider and the same provider should be integrated with the authentication flow of your application. To verify the details, we have to forward the authentication requests to the provider. On successful authentication, we receive a success message and/or profile details with which we can execute the necessary flow.
+
+***OAuth*** is an authorization mechanism that allows your application user access to a provider(Gmail/Facebook/Instagram/etc). On successful response, we (your application) receive a token with which the application can access certain APIs on behalf of a user. OAuth is convenient in case your business use case requires some certain user-facing APIs like access to Google Drive or sending tweets on your behalf. Most OAuth 2.0 providers can be used for pseudo authentication. Having said that, it can get pretty complicated if you are using multiple OAuth providers to authenticate users on top of the local authentication system.
+
+---
+
+## Cryptography
+
+- It is the science and study of hiding any text in such a way that only the intended recipients or authorized persons can read it and that any text can even use things such as invisible ink or the mechanical cryptography machines of the past.
+
+- Cryptography is necessary for securing critical or proprietary information and is used to encode private data messages by converting some plain text into ciphertext. At its core, there are two ways of doing this, more advanced methods are all built upon.
+
+### Ciphers
+
+- Ciphers are the cornerstone of cryptography. A cipher is a set of algorithms that performs encryption or decryption on a message. An encryption algorithm (E) takes a secret key (k) and a message (m) and produces a ciphertext (c). Similarly, a Decryption algorithm (D) takes a secret key (K) and the previous resulting Ciphertext (C). They are represented as follows:
+
+```
+
+E(k,m) = c
+D(k,c) = m
+
+```
+
+- This also means that for it to be a cipher, it must satisfy the consistency equation as follows, making it possible to decrypt.
+
+```
+
+D(k,E(k,m)) = m
+```
+
+Stream Ciphers:
+
+- The message is broken into characters or bits and enciphered with a key or keystream(should be random and generated independently of the message stream) that is as long as the plaintext bitstream.
+- If the keystream is random, this scheme would be unbreakable unless the keystream was acquired, making it unconditionally secure. The keystream must be provided to both parties in a secure way to prevent its release.
+
+Block Ciphers:
+
+- Block ciphers — process messages in blocks, each of which is then encrypted or decrypted.
+- A block cipher is a symmetric cipher in which blocks of plaintext are treated as a whole and used to produce ciphertext blocks. The block cipher takes blocks that are b bits long and encrypts them to blocks that are also b bits long. Block sizes are typically 64 or 128 bits long.
+
+ 
+ 
+
+Encryption
+
+- **Secret Key (Symmetric Key)**: the same key is used for encryption and decryption
+- **Public Key (Asymmetric Key)** in an asymmetric, the encryption and decryption keys are different but related. The encryption key is known as the public key and the decryption key is known as the private key. The public and private keys are known as a key pair.
+
+Symmetric Key Encryption
+
+DES
+
+- The Data Encryption Standard (DES) has been the worldwide encryption standard for a long time. IBM developed DES in 1975, and it has held up remarkably well against years of cryptanalysis. DES is a symmetric encryption algorithm with a fixed key length of 56 bits. The algorithm is still good, but because of the short key length, it is susceptible to brute-force attacks that have sufficient resources.
+
+- DES usually operates in block mode, whereby it encrypts data in 64-bit blocks. The same algorithm and key are used for both encryption and decryption.
+
+- Because DES is based on simple mathematical functions, it can be easily implemented and accelerated in hardware.
+
+Triple DES
+
+- With advances in computer processing power, the original 56-bit DES key became too short to withstand an attacker with even a limited budget. One way of increasing the effective key length of DES without changing the well-analyzed algorithm itself is to use the same algorithm with different keys several times in a row.
+
+- The technique of applying DES three times in a row to a plain text block is called Triple DES (3DES). The 3DES technique is shown in Figure. Brute-force attacks on 3DES are considered unfeasible today. Because the basic algorithm has been tested in the field for more than 25 years, it is considered to be more trustworthy than its predecessor.
+
+
+AES
+
+- On October 2, 2000, The U.S. National Institute of Standards and Technology (NIST) announced the selection of the Rijndael cipher as the AES algorithm. This cipher, developed by Joan Daemen and Vincent Rijmen, has a variable block length and key length. The algorithm currently specifies how to use keys with a length of 128, 192, or 256 bits to encrypt blocks with a length of 128, 192, or 256 bits (all nine combinations of key length and block length are possible). Both block and key lengths can be extended easily to multiples of 32 bits.
+
+- AES was chosen to replace DES and 3DES because they are either too weak (DES, in terms of key length) or too slow (3DES) to run on modern, efficient hardware. AES is more efficient and much faster, usually by a factor of 5 compared to DES on the same hardware. AES is also more suitable for high throughput, especially if pure software encryption is used. However, AES is a relatively young algorithm, and as the golden rule of cryptography states, “A more mature algorithm is always more trusted.”
+
+Asymmetric Key Algorithm
+
+
+
+- In a symmetric key system, Alice first puts the secret message in a box and then padlocks the box using a lock to which she has a key. She then sends the box to Bob through regular mail. When Bob receives the box, he uses an identical copy of Alice's key (which he has obtained previously) to open the box and read the message.
+
+- In an asymmetric key system, instead of opening the box when he receives it, Bob simply adds his own personal lock to the box and returns the box through public mail to Alice. Alice uses her key to remove her lock and returns the box to Bob, with Bob's lock still in place. Finally, Bob uses his key to remove his lock and reads the message from Alice.
+- The critical advantage in an asymmetric system is that Alice never needs to send a copy of her key to Bob. This reduces the possibility that a third party (for example, an unscrupulous postmaster) can copy the key while it is in transit to Bob, allowing that third party to spy on all future messages sent by Alice. In addition, if Bob is careless and allows someone else to copy his key, Alice's messages to Bob are compromised, but Alice's messages to other people remain secret
+
+**NOTE**: In terms of TLS key exchange, this is the common approach.
+
+Diffie-Hellman
+
+- The protocol has two system parameters, p and g. They are both public and may be used by everybody. Parameter p is a prime number, and parameter g (usually called a generator) is an integer that is smaller than p, but with the following property: For every number n between 1 and p – 1 inclusive, there is a power k of g such that n = gk mod p.
+- Diffie Hellman algorithm is an asymmetric algorithm used to establish a shared secret for a symmetric key algorithm. Nowadays most of the people use hybrid cryptosystem i.e, a combination of symmetric and asymmetric encryption. Asymmetric Encryption is used as a technique in key exchange mechanism to share a secret key and after the key is shared between sender and receiver, the communication will take place using symmetric encryption. The shared secret key will be used to encrypt the communication.
+- Refer:
+
+RSA
+
+- The RSA algorithm is very flexible and has a variable key length where, if necessary, speed can be traded for the level of security of the algorithm. The RSA keys are usually 512 to 2048 bits long. RSA has withstood years of extensive cryptanalysis. Although those years neither proved nor disproved RSA's security, they attest to a confidence level in the algorithm. RSA security is based on the difficulty of factoring very large numbers. If an easy method of factoring these large numbers were discovered, the effectiveness of RSA would be destroyed.
+- Refer:
+
+ **NOTE**: RSA Keys can be used for key exchange just like Diffie Hellman
+
+Hashing Algorithms
+
+- Hashing is one of the mechanisms used for data integrity assurance. Hashing is based on a one-way mathematical function, which is relatively easy to compute but significantly harder to reverse.
+
+- A hash function, which is a one-way function to input data to produce a fixed-length digest (fingerprint) of output data. The digest is cryptographically strong; that is, it is impossible to recover input data from its digest. If the input data changes just a little, the digest (fingerprint) changes substantially in what is called an avalanche effect.
+
+- More:
+ -
+ -
+
+MD5
+
+- MD5 is a one-way function with which it is easy to compute the hash from the given input data, but it is unfeasible to compute input data given only a hash.
+
+SHA-1
+
+- MD5 is considered less secure than SHA-1 because MD5 has some weaknesses.
+- HA-1 also uses a stronger, 160-bit digest, which makes MD5 the second choice as hash methods are concerned.
+- The algorithm takes a message of less than 264 bits in length and produces a 160-bit message digest. This algorithm is slightly slower than MD5.
+
+ **NOTE**: SHA-1 is also recently demonstrated to be broken, Minimum current recommendation is SHA-256
+
+Digital Certificates
+
+- Digital signatures, provide a means to digitally authenticate devices and individual users. In public-key cryptography, such as the RSA encryption system, each user has a key-pair containing both a public key and a private key. The keys act as complements, and anything encrypted with one of the keys can be decrypted with the other. In simple terms, a signature is formed when data is encrypted with a user's private key. The receiver verifies the signature by decrypting the message with the sender's public key.
+
+- Key management is often considered the most difficult task in designing and implementing cryptographic systems. Businesses can simplify some of the deployment and management issues that are encountered with secured data communications by employing a Public Key Infrastructure (PKI). Because corporations often move security-sensitive communications across the Internet, an effective mechanism must be implemented to protect sensitive information from the threats presented on the Internet.
+
+- PKI provides a hierarchical framework for managing digital security attributes. Each PKI participant holds a digital certificate that has been issued by a CA (either public or private). The certificate contains several attributes that are used when parties negotiate a secure connection. These attributes must include the certificate validity period, end-host identity information, encryption keys that will be used for secure communications, and the signature of the issuing CA. Optional attributes may be included, depending on the requirements and capability of the PKI.
+- A CA can be a trusted third party, such as VeriSign or Entrust, or a private (in-house) CA that you establish within your organization.
+- The fact that the message could be decrypted using the sender's public key means that the holder of the private key created the message. This process relies on the receiver having a copy of the sender's public key and knowing with a high degree of certainty that it really does belong to the sender and not to someone pretending to be the sender.
+- To validate the CA's signature, the receiver must know the CA's public key. Normally, this is handled out-of-band or through an operation performed during the installation of the certificate. For instance, most web browsers are configured with the root certificates of several CAs by default.
+
+CA Enrollment process
+
+1. The end host generates a private-public key pair.
+2. The end host generates a certificate request, which it forwards to the CA.
+3. Manual human intervention is required to approve the enrollment request, which is received by the CA.
+4. After the CA operator approves the request, the CA signs the certificate request with its private key and returns the completed certificate to the end host.
+5. The end host writes the certificate into a nonvolatile storage area (PC hard disk or NVRAM on Cisco routers).
+
+**Refer**:
+
+## Login Security
+
+### SSH
+
+- SSH, the Secure Shell, is a popular, powerful, software-based approach to network security.
+- Whenever data is sent by a computer to the network, SSH automatically encrypts (scrambles) it. Then, when the data reaches its intended recipient, SSH automatically decrypts (unscrambles) it.
+- The result is transparent encryption: users can work normally, unaware that their communications are safely encrypted on the network. In addition, SSH can use modern, secure encryption algorithms based on how it's being configured and is effective enough to be found within mission-critical applications at major corporations.
+- SSH has a client/server architecture
+- An SSH server program, typically installed and run by a system administrator, accepts or rejects incoming connections to its host computer. Users then run SSH client programs, typically on other computers, to make requests of the SSH server, such as “Please log me in,” “Please send me a file,” or “Please execute this command.” All communications between clients and servers are securely encrypted and protected from modification.
+
+ 
+
+What SSH is not:
+
+- Although SSH stands for Secure Shell, it is not a true shell in the sense of the Unix Bourne shell and C shell. It is not a command interpreter, nor does it provide wildcard expansion, command history, and so forth. Rather, SSH creates a channel for running a shell on a remote computer, with end-to-end encryption between the two systems.
+
+The major features and guarantees of the SSH protocol are:
+
+- Privacy of your data, via strong encryption
+- Integrity of communications, guaranteeing they haven’t been altered
+- Authentication, i.e., proof of identity of senders and receivers
+- Authorization, i.e., access control to accounts
+- Forwarding or tunnelling to encrypt other TCP/IP-based sessions
+
+### Kerberos
+
+- According to Greek mythology Kerberos (Cerberus) was the gigantic, three-headed dog that guards the gates of the underworld to prevent the dead from leaving.
+- So when it comes to Computer Science, Kerberos is a network authentication protocol and is currently the default authentication technology used by Microsoft Active Directory to authenticate users to services within a local area network.
+
+- Kerberos uses symmetric-key cryptography and requires a trusted third-party authentication service to verify user identities. So they used the name of Kerberos for their computer network authentication protocol as the three heads of the Kerberos represent:
+ - a client: A user/ a service
+ - a server: Kerberos protected hosts reside
+
+ 
+ - a Key Distribution Center (KDC), which acts as the trusted third-party authentication service.
+
+The KDC includes the following two servers:
+
+- Authentication Server (AS) that performs the initial authentication and issues ticket-granting tickets (TGT) for users.
+- Ticket-Granting Server (TGS) that issues service tickets that are based on the initial ticket-granting tickets (TGT).
+
+ 
+
+
+### Certificate Chain
+
+The first part of the output of the OpenSSL command shows three certificates numbered 0, 1, and 2(not 2 anymore). Each certificate has a subject, s, and an issuer, i. The first certificate, number 0, is called the end-entity certificate. The subject line tells us it’s valid for any subdomain of google.com because its subject is set to *.google.com.
+
+
+`$ openssl s_client -connect www.google.com:443 -CApath /etc/ssl/certs
+CONNECTED(00000005)
+depth=2 OU = GlobalSign Root CA - R2, O = GlobalSign, CN = GlobalSign
+verify return:1
+depth=1 C = US, O = Google Trust Services, CN = GTS CA 1O1
+verify return:1
+depth=0 C = US, ST = California, L = Mountain View, O = Google LLC, CN = www.google.com
+verify return:1`
+`---
+Certificate chain
+ 0 s:/C=US/ST=California/L=Mountain View/O=Google LLC/CN=www.google.com
+ i:/C=US/O=Google Trust Services/CN=GTS CA 1O1
+ 1 s:/C=US/O=Google Trust Services/CN=GTS CA 1O1
+ i:/OU=GlobalSign Root CA - R2/O=GlobalSign/CN=GlobalSign
+---`
+`Server certificate`
+
+- The issuer line indicates it’s issued by Google Internet Authority G2, which also happens to be the subject of the second certificate, number 1
+- What the OpenSSL command line doesn’t show here is the trust store that contains the list of CA certificates trusted by the system OpenSSL runs on.
+- The public certificate of GlobalSign Authority must be present in the system’s trust store to close the verification chain. This is called a chain of trust, and the figure below summarizes its behaviour at a high level.
+
+ 
+
+- High-level view of the concept of chain of trust applied to verifying the authenticity of a website. The Root CA in the Firefox trust store provides the initial trust to verify the entire chain and trust the end-entity certificate.
+
+### TLS Handshake
+
+1. The client sends a HELLO message to the server with a list of protocols and algorithms it supports.
+2. The server says HELLO back and sends its chain of certificates. Based on the capabilities of the client, the server picks a cipher suite.
+3. If the cipher suite supports ephemeral key exchange, like ECDHE does(ECDHE is an algorithm known as the Elliptic Curve Diffie-Hellman Exchange), the server and the client negotiate a pre-master key with the Diffie-Hellman algorithm. The pre-master key is never sent over the wire.
+4. The client and server create a session key that will be used to encrypt the data transiting through the connection.
+
+At the end of the handshake, both parties possess a secret session key used to encrypt data for the rest of the connection. This is what OpenSSL refers to as Master-Key
+
+**NOTE**
+
+- There are 3 versions of TLS , TLS 1.0, 1.1 & 1.2
+- TLS 1.0 was released in 1999, making it a nearly two-decade-old protocol. It has been known to be vulnerable to attacks—such as BEAST and POODLE—for years, in addition to supporting weak cryptography, which doesn’t keep modern-day connections sufficiently secure.
+- TLS 1.1 is the forgotten “middle child.” It also has bad cryptography like its younger sibling. In most software, it was leapfrogged by TLS 1.2 and it’s rare to see TLS 1.1 used.
+
+### “Perfect” Forward Secrecy
+
+- The term “ephemeral” in the key exchange provides an important security feature mis-named perfect forward secrecy (PFS) or just “Forward Secrecy”.
+- In a non-ephemeral key exchange, the client sends the pre-master key to the server by encrypting it with the server’s public key. The server then decrypts the pre-master key with its private key. If at a later point in time, the private key of the server is compromised, an attacker can go back to this handshake, decrypt the pre-master key, obtain the session key, and decrypt the entire traffic. Non-ephemeral key exchanges are vulnerable to attacks that may happen in the future on recorded traffic. And because people seldom change their password, decrypting data from the past may still be valuable for an attacker.
+- An ephemeral key exchange like DHE, or its variant on elliptic curve, ECDHE, solves this problem by not transmitting the pre-master key over the wire. Instead, the pre-master key is computed by both the client and the server in isolation, using nonsensitive information exchanged publicly. Because the pre-master key can’t be decrypted later by an attacker, the session key is safe from future attacks: hence, the term perfect forward secrecy.
+- Keys are changed every X blocks along the stream. That prevents an attacker from simply sniffing the stream and applying brute force to crack the whole thing. "Forward secrecy" means that just because I can decrypt block M, does not mean that I can decrypt block Q
+- Downside:
+ - The downside to PFS is that all those extra computational steps induce latency on the handshake and slow the user down. To avoid repeating this expensive work at every connection, both sides cache the session key for future use via a technique called session resumption. This is what the session-ID and TLS ticket are for: they allow a client and server that share a session ID to skip over the negotiation of a session key, because they already agreed on one previously, and go directly to exchanging data securely.
diff --git a/courses/level101/security/images/image1.png b/courses/level101/security/images/image1.png
new file mode 100644
index 0000000..59f80f1
Binary files /dev/null and b/courses/level101/security/images/image1.png differ
diff --git a/courses/level101/security/images/image10.png b/courses/level101/security/images/image10.png
new file mode 100644
index 0000000..b781329
Binary files /dev/null and b/courses/level101/security/images/image10.png differ
diff --git a/courses/level101/security/images/image11.png b/courses/level101/security/images/image11.png
new file mode 100644
index 0000000..5a660c3
Binary files /dev/null and b/courses/level101/security/images/image11.png differ
diff --git a/courses/level101/security/images/image122.png b/courses/level101/security/images/image122.png
new file mode 100644
index 0000000..bb4a191
Binary files /dev/null and b/courses/level101/security/images/image122.png differ
diff --git a/courses/level101/security/images/image14.png b/courses/level101/security/images/image14.png
new file mode 100644
index 0000000..bd23a37
Binary files /dev/null and b/courses/level101/security/images/image14.png differ
diff --git a/courses/level101/security/images/image15.png b/courses/level101/security/images/image15.png
new file mode 100644
index 0000000..1896e90
Binary files /dev/null and b/courses/level101/security/images/image15.png differ
diff --git a/courses/level101/security/images/image17.png b/courses/level101/security/images/image17.png
new file mode 100644
index 0000000..7a32100
Binary files /dev/null and b/courses/level101/security/images/image17.png differ
diff --git a/courses/level101/security/images/image18.png b/courses/level101/security/images/image18.png
new file mode 100644
index 0000000..dbefcf9
Binary files /dev/null and b/courses/level101/security/images/image18.png differ
diff --git a/courses/level101/security/images/image19.png b/courses/level101/security/images/image19.png
new file mode 100644
index 0000000..8bc9783
Binary files /dev/null and b/courses/level101/security/images/image19.png differ
diff --git a/courses/level101/security/images/image20.png b/courses/level101/security/images/image20.png
new file mode 100644
index 0000000..34ac1c0
Binary files /dev/null and b/courses/level101/security/images/image20.png differ
diff --git a/courses/level101/security/images/image22.png b/courses/level101/security/images/image22.png
new file mode 100644
index 0000000..056e7ea
Binary files /dev/null and b/courses/level101/security/images/image22.png differ
diff --git a/courses/level101/security/images/image23.png b/courses/level101/security/images/image23.png
new file mode 100644
index 0000000..2669d36
Binary files /dev/null and b/courses/level101/security/images/image23.png differ
diff --git a/courses/level101/security/images/image26.png b/courses/level101/security/images/image26.png
new file mode 100644
index 0000000..ccc98f6
Binary files /dev/null and b/courses/level101/security/images/image26.png differ
diff --git a/courses/level101/security/images/image5.png b/courses/level101/security/images/image5.png
new file mode 100644
index 0000000..b5f5adf
Binary files /dev/null and b/courses/level101/security/images/image5.png differ
diff --git a/courses/level101/security/images/image6.png b/courses/level101/security/images/image6.png
new file mode 100644
index 0000000..9c16b5b
Binary files /dev/null and b/courses/level101/security/images/image6.png differ
diff --git a/courses/level101/security/images/image7.png b/courses/level101/security/images/image7.png
new file mode 100644
index 0000000..f91bf57
Binary files /dev/null and b/courses/level101/security/images/image7.png differ
diff --git a/courses/level101/security/images/image8.png b/courses/level101/security/images/image8.png
new file mode 100644
index 0000000..782d84a
Binary files /dev/null and b/courses/level101/security/images/image8.png differ
diff --git a/courses/level101/security/images/image9.png b/courses/level101/security/images/image9.png
new file mode 100644
index 0000000..69a2f4a
Binary files /dev/null and b/courses/level101/security/images/image9.png differ
diff --git a/courses/level101/security/intro.md b/courses/level101/security/intro.md
new file mode 100644
index 0000000..e8415cc
--- /dev/null
+++ b/courses/level101/security/intro.md
@@ -0,0 +1,26 @@
+# Security
+
+## Prerequisites
+
+1. [Linux Basics](https://linkedin.github.io/school-of-sre/level101/linux_basics/intro/)
+
+2. [Linux Networking](https://linkedin.github.io/school-of-sre/level101/linux_networking/intro/)
+
+
+## What to expect from this course
+
+The course covers fundamentals of information security along with touching on subjects of system security, network & web security. This course aims to get you familiar with the basics of information security in day to day operations & then as an SRE develop the mindset of ensuring that security takes a front-seat while developing solutions. The course also serves as an introduction to common risks and best practices along with practical ways to find out vulnerable systems and loopholes which might become compromised if not secured.
+
+
+## What is not covered under this course
+
+The courseware is not an ethical hacking workshop or a very deep dive into the fundamentals of the problems. The course does not deal with hacking or breaking into systems but rather an approach on how to ensure you don’t get into those situations and also to make you aware of different ways a system can be compromised.
+
+
+## Course Contents
+
+1. [Fundamentals](https://linkedin.github.io/school-of-sre/level101/security/fundamentals/)
+2. [Network Security](https://linkedin.github.io/school-of-sre/level101/security/network_security/)
+3. [Threats, Attacks & Defence](https://linkedin.github.io/school-of-sre/level101/security/threats_attacks_defences/)
+4. [Writing Secure Code & More](https://linkedin.github.io/school-of-sre/level101/security/writing_secure_code/)
+5. [Conclusion](https://linkedin.github.io/school-of-sre/level101/security/conclusion/)
diff --git a/courses/level101/security/network_security.md b/courses/level101/security/network_security.md
new file mode 100644
index 0000000..2ddf2f6
--- /dev/null
+++ b/courses/level101/security/network_security.md
@@ -0,0 +1,494 @@
+# Part II: Network Security
+
+## Introduction
+
+- TCP/IP is the dominant networking technology today. It is a five-layer architecture. These layers are, from top to bottom, the application layer, the transport layer (TCP), the network layer (IP), the data-link layer, and the physical layer. In addition to TCP/IP, there also are other networking technologies. For convenience, we use the OSI network model to represent non-TCP/IP network technologies. Different networks are interconnected using gateways. A gateway can be placed at any layer.
+- The OSI model is a seven-layer architecture. The OSI architecture is similar to the TCP/IP architecture, except that the OSI model specifies two additional layers between the application layer and the transport layer in the TCP/IP architecture. These two layers are the presentation layer and the session layer. Figure 5.1 shows the relationship between the TCP/IP layers and the OSI layers. The application layer in TCP/IP corresponds to the application layer and the presentation layer in OSI. The transport layer in TCP/IP corresponds to the session layer and the transport layer in OSI. The remaining three layers in the TCP/IP architecture are one-to-one correspondent to the remaining three layers in the OSI model.
+
+ 
+ Correspondence between layers of the TCP/IP architecture and the OSI model. Also shown are placements of cryptographic algorithms in network layers, where the dotted arrows indicate actual communications of cryptographic algorithms
+
+The functionalities of OSI layers are briefly described as follows:
+
+1. The application layer serves as an interface between applications and network programs. It supports application programs and end-user processing. Common application-layer programs include remote logins, file transfer, email, and Web browsing.
+2. The presentation layer is responsible for dealing with data that is formed differently. This protocol layer allows application-layer programs residing on different sides of a communication channel with different platforms to understand each other's data formats regardless of how they are presented.
+3. The session layer is responsible for creating, managing, and closing a communication connection.
+4. The transport layer is responsible for providing reliable connections, such as packet sequencing, traffic control, and congestion control.
+5. The network layer is responsible for routing device-independent data packets from the current hop to the next hop.
+6. The data-link layer is responsible for encapsulating device-independent data packets into device-dependent data frames. It has two sublayers: logical link control and media access control.
+7. The physical layer is responsible for transmitting device-dependent frames through some physical media.
+
+- Starting from the application layer, data generated from an application program is passed down layer-by-layer to the physical layer. Data from the previous layer is enclosed in a new envelope at the current layer, where the data from the previous layer is also just an envelope containing the data from the layer before it. This is similar to enclosing a smaller envelope in a larger one. The envelope added at each layer contains sufficient information for handling the packet. Application-layer data are divided into blocks small enough to be encapsulated in an envelope at the next layer.
+- Application data blocks are “dressed up” in the TCP/IP architecture according to the following basic steps. At the sending side, an application data block is encapsulated in a TCP packet when it is passed down to the TCP layer. In other words, a TCP packet consists of a header and a payload, where the header corresponds to the TCP envelope and the payload is the application data block. Likewise, the TCP packet will be encapsulated in an IP packet when it is passed down to the IP layer. An IP packet consists of a header and a payload, which is the TCP packet passed down from the TCP layer. The IP packet will be encapsulated in a device-dependent frame (e.g., an Ethernet frame) when it is passed down to the data-link layer. A frame has a header, and it may also have a trailer. For example, in addition to having a header, an Ethernet frame also has a 32-bit cyclic redundancy check (CRC) trailer. When it is passed down to the physical layer, a frame will be transformed into a sequence of media signals for transmission
+
+ 
+ Flow Diagram of a Packet Generation
+
+- At the destination side, the medium signals are converted by the physical layer into a frame, which is passed up to the data-link layer. The data-link layer passes the frame payload (i.e., the IP packet encapsulated in the frame) up to the IP layer. The IP layer passes the IP payload, namely, the TCP packet encapsulated in the IP packet, up to the TCP layer. The TCP layer passes the TCP payload, namely, the application data block, up to the application layer. When a packet arrives at a router, it only goes up to the IP layer, where certain fields in the IP header are modified (e.g., the value of TTL is decreased by 1). This modified packet is then passed back down layer-by-layer to the physical layer for further transmission.
+
+### Public Key Infrastructure
+
+- To deploy cryptographic algorithms in network applications, we need a way to distribute secret keys using open networks. Public-key cryptography is the best way to distribute these secret keys. To use public-key cryptography, we need to build a public-key infrastructure (PKI) to support and manage public-key certificates and certificate authority (CA) networks. In particular, PKIs are set up to perform the following functions:
+ - Determine the legitimacy of users before issuing public-key certificates to them.
+ - Issue public-key certificates upon user requests.
+ - Extend public-key certificates valid time upon user requests.
+ - Revoke public-key certificates upon users' requests or when the corresponding private keys are compromised.
+ - Store and manage public-key certificates.
+ - Prevent digital signature signers from denying their signatures.
+ - Support CA networks to allow different CAs to authenticate public-key certificates issued by other CAs.
+ - X.509:
+
+### IPsec: A Security Protocol at the Network Layer
+
+- IPsec is a major security protocol at the network layer
+- IPsec provides a potent platform for constructing virtual private networks (VPN). VPNs are private networks overlayed on public networks.
+- The purpose of deploying cryptographic algorithms at the network layer is to encrypt or authenticate IP packets (either just the payloads or the whole packets).
+- IPsec also specifies how to exchange keys. Thus, IPsec consists of authentication protocols, encryption protocols, and key exchange protocols. They are referred to, respectively, as authentication header (AH), encapsulating security payload (ESP), and Internet key exchange (IKE).
+
+### PGP & S/MIME : Email Security
+
+- There are several security protocols at the application layer. The most used of these protocols are email security protocols namely PGP and S/MIME.
+- SMTP (“Simple Mail Transfer Protocol”) is used for sending and delivering from a client to a server via port 25: it’s the outgoing server. On the contrary, POP (“Post Office Protocol”) allows the users to pick up the message and download it into their inbox: it’s the incoming server. The latest version of the Post Office Protocol is named POP3, and it’s been used since 1996; it uses port 110
+
+PGP
+
+- PGP implements all major cryptographic algorithms, the ZIP compression algorithm, and the Base64 encoding algorithm.
+- It can be used to authenticate a message, encrypt a message, or both. PGP follows the following general process: authentication, ZIP compression, encryption, and Base64 encoding.
+- The Base64 encoding procedure makes the message ready for SMTP transmission
+
+GPG (GnuPG)
+
+- GnuPG is another free encryption standard that companies may use that is based on OpenPGP.
+- GnuPG serves as a replacement for Symantec’s PGP.
+- The main difference is the supported algorithms. However, GnuPG plays nice with PGP by design. Because GnuPG is open, some businesses would prefer the technical support and the user interface that comes with Symantec’s PGP.
+- It is important to note that there are some nuances between the compatibility of GnuPG and PGP, such as the compatibility between certain algorithms, but in most applications such as email, there are workarounds. One such algorithm is the IDEA Module which isn’t included in GnuPG out of the box due to patent issues.
+
+S/MIME
+
+- SMTP can only handle 7-bit ASCII text (You can use UTF-8 extensions to alleviate these limitations, ) messages. While POP can handle other content types besides 7-bit ASCII, POP may, under a common default setting, download all the messages stored in the mail server to the user's local computer. After that, if POP removes these messages from the mail server. This makes it difficult for the users to read their messages from multiple computers.
+- The Multipurpose Internet Mail Extension protocol (MIME) was designed to support sending and receiving email messages in various formats, including nontext files generated by word processors, graphics files, sound files, and video clips. Moreover, MIME allows a single message to include mixed types of data in any combination of these formats.
+- The Internet Mail Access Protocol (IMAP), operated on TCP port 143(only for non-encrypted), stores (Configurable on both server & client just like PoP) incoming email messages in the mail server until the user deletes them deliberately. This allows the users to access their mailbox from multiple machines and download messages to a local machine without deleting it from the mailbox in the mail server.
+
+SSL/TLS
+
+- SSL uses a PKI to decide if a server’s public key is trustworthy by requiring servers to use a security certificate signed by a trusted CA.
+- When Netscape Navigator 1.0 was released, it trusted a single CA operated by the RSA Data Security corporation.
+- The server’s public RSA keys were used to be stored in the security certificate, which can then be used by the browser to establish a secure communication channel. The security certificates we use today still rely on the same standard (named X.509) that Netscape Navigator 1.0 used back then.
+- Netscape intended to train users(though this didn’t work out later) to differentiate secure communications from insecure ones, so they put a lock icon next to the address bar. When the lock is open, the communication is insecure. A closed lock means communication has been secured with SSL, which required the server to provide a signed certificate. You’re obviously familiar with this icon as it’s been in every browser ever since. The engineers at Netscape truly created a standard for secure internet communications.
+- A year after releasing SSL 2.0, Netscape fixed several security issues and released SSL 3.0, a protocol that, albeit being officially deprecated since June 2015, remains in use in certain parts of the world more than 20 years after its introduction. To standardize SSL, the Internet Engineering Task Force (IETF) created a slightly modified SSL 3.0 and, in 1999, unveiled it as Transport Layer Security (TLS) 1.0. The name change between SSL and TLS continues to confuse people today. Officially, TLS is the new SSL, but in practice, people use SSL and TLS interchangeably to talk about any version of the protocol.
+
+- Must See:
+ -
+ -
+
+## Network Perimeter Security
+
+Let us see how we keep a check on the perimeter i.e the edges, the first layer of protection
+
+### General Firewall Framework
+
+- Firewalls are needed because encryption algorithms cannot effectively stop malicious packets from getting into an edge network.
+- This is because IP packets, regardless of whether they are encrypted, can always be forwarded into an edge network.
+- Firewalls that were developed in the 1990s are important instruments to help restrict network access. A firewall may be a hardware device, a software package, or a combination of both.
+- Packets flowing into the internal network from the outside should be evaluated before they are allowed to enter. One of the critical elements of a firewall is its ability to examine packets without imposing a negative impact on communication speed while providing security protections for the internal network.
+- The packet inspection that is carried out by firewalls can be done using several different methods. Based on the particular method used by the firewall, it can be characterized as either a packet filter, circuit gateway, application gateway, or dynamic packet filter.
+
+### Packet Filters
+
+- It inspects ingress packets coming to an internal network from outside and inspects egress packets going outside from an internal network
+- Packing filtering only inspects IP headers and TCP headers, not the payloads generated at the application layer
+- A packet-filtering firewall uses a set of rules to determine whether a packet should be allowed or denied to pass through.
+- 2 types:
+ - Stateless
+ - It treats each packet as an independent object, and it does not keep track of any previously processed packets. In other words, stateless filtering inspects a packet when it arrives and makes a decision without leaving any record of the packet being inspected.
+
+ - Stateful
+ - Stateful filtering, also referred to as connection-state filtering, keeps track of connections between an internal host and an external host. A connection state (or state, for short) indicates whether it is a TCP connection or a UDP connection and whether the connection is established.
+
+### Circuit Gateways
+
+- Circuit gateways, also referred to as circuit-level gateways, are typically operated at the transportation layer
+- They evaluate the information of the IP addresses and the port numbers contained in TCP (or UDP) headers and use it to determine whether to allow or to disallow an internal host and an external host to establish a connection.
+- It is common practice to combine packet filters and circuit gateways to form a dynamic packet filter (DPF).
+
+### Application Gateways(ALG)
+
+- Aka PROXY Servers
+- An Application Level Gateway (ALG) acts as a proxy for internal hosts, processing service requests from external clients.
+- An ALG performs deep inspections on each IP packet (ingress or egress).
+- In particular, an ALG inspects application program formats contained in the packet (e.g., MIME format or SQL format) and examines whether its payload is permitted.
+ - Thus, an ALG may be able to detect a computer virus contained in the payload. Because an ALG inspects packet payloads, it may be able to detect malicious code and quarantine suspicious packets, in addition to blocking packets with suspicious IP addresses and TCP ports. On the other hand, an ALG also incurs substantial computation and space overheads.
+
+### Trusted Systems & Bastion Hosts
+
+- A Trusted Operating System (TOS) is an operating system that meets a particular set of security requirements. Whether an operating system can be trusted or not depends on several elements. For example, for an operating system on a particular computer to be certified trusted, one needs to validate that, among other things, the following four requirements are satisfied:
+ - Its system design contains no defects;
+ - Its system software contains no loopholes;
+ - Its system is configured properly; and
+ - Its system management is appropriate.
+
+- Bastion Hosts
+ - Bastion hosts are computers with strong defence mechanisms. They often serve as host computers for implementing application gateways, circuit gateways, and other types of firewalls. A bastion host is operated on a trusted operating system that must not contain unnecessary functionalities or programs. This measure helps to reduce error probabilities and makes it easier to conduct security checks. Only those network application programs that are necessary, for example, SSH, DNS, SMTP, and authentication programs, are installed on a bastion host.
+ - Bastion hosts are also primarily used as controlled ingress points so that the security monitoring can focus more narrowly on actions happening at a single point closely.
+
+---
+
+## Common Techniques & Scannings, Packet Capturing
+
+### Scanning Ports with Nmap
+
+- Nmap ("Network Mapper") is a free and open-source (license) utility for network discovery and security auditing. Many systems and network administrators also find it useful for tasks such as network inventory, managing service upgrade schedules, and monitoring host or service uptime.
+- The best thing about Nmap is it’s free and open-source and is very flexible and versatile
+- Nmap is often used to determine alive hosts in a network, open ports on those hosts, services running on those open ports, and version identification of that service on that port.
+- More at http://scanme.nmap.org/
+
+```
+nmap [scan type] [options] [target specification]
+```
+
+
+Nmap uses 6 different port states:
+
+- **Open** — An open port is one that is actively accepting TCP, UDP or SCTP connections. Open ports are what interests us the most because they are the ones that are vulnerable to attacks. Open ports also show the available services on a network.
+- **Closed** — A port that receives and responds to Nmap probe packets but there is no application listening on that port. Useful for identifying that the host exists and for OS detection.
+- **Filtered** — Nmap can’t determine whether the port is open because packet filtering prevents its probes from reaching the port. Filtering could come from firewalls or router rules. Often little information is given from filtered ports during scans as the filters can drop the probes without responding or respond with useless error messages e.g. destination unreachable.
+- **Unfiltered** — Port is accessible but Nmap doesn’t know if it is open or closed. Only used in ACK scan which is used to map firewall rulesets. Other scan types can be used to identify whether the port is open.
+- **Open/filtered** — Nmap is unable to determine between open and filtered. This happens when an open port gives no response. No response could mean that the probe was dropped by a packet filter or any response is blocked.
+- **Closed/filtered** — Nmap is unable to determine whether a port is closed or filtered. Only used in the IP ID idle scan.
+
+### Types of Nmap Scan:
+
+1. TCP Connect
+ - TCP Connect scan completes the 3-way handshake.
+ - If a port is open, the operating system completes the TCP three-way handshake and the port scanner immediately closes the connection to avoid DOS. This is “noisy” because the services can log the sender IP address and might trigger Intrusion Detection Systems.
+2. UDP Scan
+ - This scan checks to see if any UDP ports are listening.
+ - Since UDP does not respond with a positive acknowledgement like TCP and only responds to an incoming UDP packet when the port is closed,
+
+3. SYN Scan
+ - SYN scan is another form of TCP scanning.
+ - This scan type is also known as “half-open scanning” because it never actually opens a full TCP connection.
+ - The port scanner generates a SYN packet. If the target port is open, it will respond with an SYN-ACK packet. The scanner host responds with an RST packet, closing the connection before the handshake is completed.
+ - If the port is closed but unfiltered, the target will instantly respond with an RST packet.
+ - SYN scan has the advantage that the individual services never actually receive a connection.
+
+4. FIN Scan
+ - This is a stealthy scan, like the SYN scan, but sends a TCP FIN packet instead.
+
+5. ACK Scan
+ - Ack scanning determines whether the port is filtered or not.
+6. Null Scan
+ - Another very stealthy scan that sets all the TCP header flags to off or null.
+ - This is not normally a valid packet and some hosts will not know what to do with this.
+7. XMAS Scan
+ - Similar to the NULL scan except for all the flags in the TCP header is set to on
+8. RPC Scan
+ - This special type of scan looks for machine answering to RPC (Remote Procedure Call) services
+9. IDLE Scan
+ - It is a super stealthy method whereby the scan packets are bounced off an external host.
+ - You don’t need to have control over the other host but it does have to set up and meet certain requirements. You must input the IP address of our “zombie” host and what port number to use. It is one of the more controversial options in Nmap since it only has a use for malicious attacks.
+
+Scan Techniques
+
+A couple of scan techniques which can be used to gain more information about a system and its ports. You can read more at
+
+### OpenVAS
+
+- OpenVAS is a full-featured vulnerability scanner.
+- OpenVAS is a framework of services and tools that provides a comprehensive and powerful vulnerability scanning and management package
+- OpenVAS, which is an open-source program, began as a fork of the once-more-popular scanning program, Nessus.
+- OpenVAS is made up of three main parts. These are:
+ - a regularly updated feed of Network Vulnerability Tests (NVTs);
+ - a scanner, which runs the NVTs; and
+ - an SQLite 3 database for storing both your test configurations and the NVTs’ results and configurations.
+ -
+
+### WireShark
+
+- Wireshark is a protocol analyzer.
+- This means Wireshark is designed to decode not only packet bits and bytes but also the relations between packets and protocols.
+- Wireshark understands protocol sequences.
+
+A simple demo of Wireshark
+
+1. Capture only udp packets:
+ - Capture filter = “udp”
+
+2. Capture only tcp packets
+ - Capture filter = “tcp”
+
+3. TCP/IP 3 way Handshake
+ 
+
+4. Filter by IP address: displays all traffic from IP, be it source or destination
+ - ip.addr == 192.168.1.1
+5. Filter by source address: display traffic only from IP source
+ - ip.src == 192.168.0.1
+
+6. Filter by destination: display traffic only form IP destination
+ - ip.dst == 192.168.0.1
+
+7. Filter by IP subnet: display traffic from subnet, be it source or destination
+ - ip.addr = 192.168.0.1/24
+
+8. Filter by protocol: filter traffic by protocol name
+ - dns
+ - http
+ - ftp
+ - arp
+ - ssh
+ - telnet
+ - icmp
+
+9. Exclude IP address: remove traffic from and to IP address
+ - !ip.addr ==192.168.0.1
+
+10. Display traffic between two specific subnet
+ - ip.addr == 192.168.0.1/24 and ip.addr == 192.168.1.1/24
+
+11. Display traffic between two specific workstations
+ - ip.addr == 192.168.0.1 and ip.addr == 192.168.0.2
+12. Filter by MAC
+ - eth.addr = 00:50:7f:c5:b6:78
+
+13. Filter TCP port
+ - tcp.port == 80
+14. Filter TCP port source
+ - tcp.srcport == 80
+15. Filter TCP port destination
+ - tcp.dstport == 80
+16. Find user agents
+ - http.user_agent contains Firefox
+ - !http.user_agent contains || !http.user_agent contains Chrome
+17. Filter broadcast traffic
+ - !(arp or icmp or dns)
+18. Filter IP address and port
+ - tcp.port == 80 && ip.addr == 192.168.0.1
+
+19. Filter all http get requests
+ - http.request
+20. Filter all http get requests and responses
+ - http.request or http.response
+21. Filter three way handshake
+ - tcp.flags.syn==1 or (tcp.seq==1 and tcp.ack==1 and tcp.len==0 and tcp.analysis.initial_rtt)
+22. Find files by type
+ - frame contains “(attachment|tar|exe|zip|pdf)”
+23. Find traffic based on keyword
+ - tcp contains facebook
+ - frame contains facebook
+24. Detecting SYN Floods
+ - tcp.flags.syn == 1 and tcp.flags.ack == 0
+
+**Wireshark Promiscuous Mode**
+ - By default, Wireshark only captures packets going to and from the computer where it runs. By checking the box to run Wireshark in Promiscuous Mode in the Capture Settings, you can capture most of the traffic on the LAN.
+
+### DumpCap
+
+- Dumpcap is a network traffic dump tool. It captures packet data from a live network and writes the packets to a file. Dumpcap’s native capture file format is pcapng, which is also the format used by Wireshark.
+- By default, Dumpcap uses the pcap library to capture traffic from the first available network interface and writes the received raw packet data, along with the packets’ time stamps into a pcapng file. The capture filter syntax follows the rules of the pcap library.
+- The Wireshark command-line utility called 'dumpcap.exe' can be used to capture LAN traffic over an extended period of time.
+- Wireshark itself can also be used, but dumpcap does not significantly utilize the computer's memory while capturing for long periods.
+
+### DaemonLogger
+
+- Daemonlogger is a packet logging application designed specifically for use in Network and Systems Management (NSM) environments.
+- The biggest benefit Daemonlogger provides is that, like Dumpcap, it is simple to use for capturing packets. In order to begin capturing, you need only to invoke the command and specify an interface.
+ - daemonlogger –i eth1
+ - This option, by default, will begin capturing packets and logging them to the current working directory.
+ - Packets will be collected until the capture file size reaches 2 GB, and then a new file will be created. This will continue indefinitely until the process is halted.
+
+### NetSniff-NG
+
+- Netsniff-NG is a high-performance packet capture utility
+- While the utilities we’ve discussed to this point rely on Libpcap for capture, Netsniff-NG utilizes zero-copy mechanisms to capture packets. This is done with the intent to support full packet capture over high throughput links.
+- To begin capturing packets with Netsniff-NG, we have to specify an input and output. In most cases, the input will be a network interface, and the output will be a file or folder on disk.
+
+ `netsniff-ng –i eth1 –o data.pcap`
+
+### Netflow
+
+- NetFlow is a feature that was introduced on Cisco routers around 1996 that provides the ability to collect IP network traffic as it enters or exits an interface. By analyzing the data provided by NetFlow, a network administrator can determine things such as the source and destination of traffic, class of service, and the causes of congestion. A typical flow monitoring setup (using NetFlow) consists of three main components:[1]
+
+ - Flow exporter: aggregates packets into flows and exports flow records towards one or more flow collectors.
+ - Flow collector: responsible for reception, storage and pre-processing of flow data received from a flow exporter.
+ - Analysis application: analyzes received flow data in the context of intrusion detection or traffic profiling, for example.
+ - Routers and switches that support NetFlow can collect IP traffic statistics on all interfaces where NetFlow is enabled, and later export those statistics as NetFlow records toward at least one NetFlow collector—typically a server that does the actual traffic analysis.
+
+### IDS
+
+A security solution that detects security-related events in your environment but does not block them.
+IDS sensors can be software and hardware-based used to collect and analyze the network traffic. These sensors are available in two varieties, network IDS and host IDS.
+
+- A host IDS is a server-specific agent running on a server with a minimum of overhead to monitor the operating system.
+- A network IDS can be embedded in a networking device, a standalone appliance, or a module monitoring the network traffic.
+
+Signature Based IDS
+
+- The signature-based IDS monitors the network traffic or observes the system and sends an alarm if a known malicious event is happening.
+- It does so by comparing the data flow against a database of known attack patterns
+- These signatures explicitly define what traffic or activity should be considered as malicious.
+- Signature-based detection has been the bread and butter of network-based defensive security for over a decade, partially because it is very similar to how malicious activity is detected at the host level with antivirus utilities
+- The formula is fairly simple: an analyst observes a malicious activity, derives indicators from the activity and develops them into signatures, and then those signatures will alert whenever the activity occurs again.
+
+- ex: SNORT & SURICATA
+
+Policy-Based IDS
+
+- The policy-based IDSs (mainly host IDSs) trigger an alarm whenever a violation occurs against the configured policy.
+- This configured policy is or should be a representation of the security policies.
+- This type of IDS is flexible and can be customized to a company's network requirements because it knows exactly what is permitted and what is not.
+- On the other hand, the signature-based systems rely on vendor specifics and default settings.
+
+
+Anomaly Based IDS
+
+- The anomaly-based IDS looks for traffic that deviates from the normal, but the definition of what is a normal network traffic pattern is the tricky part
+- Two types of anomaly-based IDS exist: statistical and nonstatistical anomaly detection
+ - Statistical anomaly detection learns the traffic patterns interactively over a period of time.
+ - In the nonstatistical approach, the IDS has a predefined configuration of the supposedly acceptable and valid traffic patterns.
+
+Host-Based IDS & Network-Based IDS
+
+- A host IDS can be described as a distributed agent residing on each server of the network that needs protection. These distributed agents are tied very closely to the underlying operating system.
+
+- Network IDSs, on the other hand, can be described as intelligent sniffing devices. Data (raw packets) is captured from the network by a network IDS, whereas host IDSs capture the data from the host on which they are installed.
+
+Honeypots
+
+- The use of decoy machines to direct intruders' attention away from the machines under protection is a major technique to preclude intrusion attacks. Any device, system, directory, or file used as a decoy to lure attackers away from important assets and to collect intrusion or abusive behaviours is referred to as a honeypot.
+- A honeypot may be implemented as a physical device or as an emulation system. The idea is to set up decoy machines in a LAN, or decoy directories/files in a file system and make them appear important, but with several exploitable loopholes, to lure attackers to attack these machines or directories/files, so that other machines, directories, and files can evade intruders' attentions. A decoy machine may be a host computer or a server computer. Likewise, we may also set up decoy routers or even decoy LANs.
+
+---
+
+## Chinks In The Armour (TCP/IP Security Issues)
+
+
+
+### IP Spoofing
+
+- In this type of attack, the attacker replaces the IP address of the sender, or in some rare cases the destination, with a different address.
+- IP spoofing is normally used to exploit a target host. In other cases, it is used to start a denial-of-service (DoS) attack.
+ - In a DoS attack, an attacker modifies the IP packet to mislead the target host into accepting the original packet as a packet sourced at a trusted host. The attacker must know the IP address of the trusted host to modify the packet headers (source IP address) so that it appears that the packets are coming from that host.
+
+IP Spoofing Detection Techniques
+
+- Direct TTL Probes
+ - In this technique we send a packet to a host of suspect spoofed IP that triggers reply and compares TTL with suspect packet; if the TTL in the reply is not the same as the packet being checked; it is a spoofed packet.
+
+ - This Technique is successful when the attacker is in a different subnet from the victim.
+ 
+
+- IP Identification Number.
+ - Send a probe to the host of suspect spoofed traffic that triggers a reply and compares IP ID with suspect traffic.
+ - If IP IDs are not in the near value of packet being checked, suspect traffic is spoofed
+
+- TCP Flow Control Method
+ - Attackers sending spoofed TCP packets will not receive the target’s SYN-ACK packets.
+ - Attackers cannot, therefore, be responsive to change in the congestion window size
+ - When the receiver still receives traffic even after a windows size is exhausted, most probably the packets are spoofed.
+
+### Covert Channel
+
+- A covert or clandestine channel can be best described as a pipe or communication channel between two entities that can be exploited by a process or application transferring information in a manner that violates the system's security specifications.
+- More specifically for TCP/IP, in some instances, covert channels are established, and data can be secretly passed between two end systems.
+ - Ex: ICMP resides at the Internet layer of the TCP/IP protocol suite and is implemented in all TCP/IP hosts. Based on the specifications of the ICMP Protocol, an ICMP Echo Request message should have an 8-byte header and a 56-byte payload. The ICMP Echo Request packet should not carry any data in the payload. However, these packets are often used to carry secret information. The ICMP packets are altered slightly to carry secret data in the payload. This makes the size of the packet larger, but no control exists in the protocol stack to defeat this behaviour. The alteration of ICMP packets allows intruders to program specialized client-server pairs. These small pieces of code export confidential information without alerting the network administrator.
+ - ICMP can be leveraged for more than data exfiltration. For eg. some C&C tools such as Loki used ICMP channel to establish encrypted interactive session back in 1996.
+
+ - Deep packet inspection has since come a long way. A lot of IDS/IPS detect ICMP tunnelling.
+ - Check for echo responses that do not contain the same payload as request
+ - Check for the volume of ICMP traffic especially for volumes beyond an acceptable threshold
+
+### IP Fragmentation Attack
+
+- The TCP/IP protocol suite, or more specifically IP, allows the fragmentation of packets.(this is a feature & not a bug)
+- IP fragmentation offset is used to keep track of the different parts of a datagram.
+- The information or content in this field is used at the destination to reassemble the datagrams
+- All such fragments have the same Identification field value, and the fragmentation offset indicates the position of the current fragment in the context of the original packet.
+
+- Many access routers and firewalls do not perform packet reassembly. In normal operation, IP fragments do not overlap, but attackers can create artificially fragmented packets to mislead the routers or firewalls. Usually, these packets are small and almost impractical for end systems because of data and computational overhead.
+- A good example of an IP fragmentation attack is the Ping of Death attack. The Ping of Death attack sends fragments that, when reassembled at the end station, create a larger packet than the maximum permissible length.
+
+TCP Flags
+
+- Data exchange using TCP does not happen until a three-way handshake has been completed. This handshake uses different flags to influence the way TCP segments are processed.
+- There are 6 bits in the TCP header that are often called flags. Namely:
+ - 6 different flags are part of the TCP header: Urgent pointer field (URG), Acknowledgment field (ACK), Push function (PSH), Reset the connection (RST), Synchronize sequence numbers (SYN), and the sender is finished with this connection (FIN).
+ 
+
+ - Abuse of the normal operation or settings of these flags can be used by attackers to launch DoS attacks. This causes network servers or web servers to crash or hang.
+
+```
+| SYN | FIN | PSH | RST | Validity|
+|------|------|-------|------|---------|
+| 1 |1 |0 |0 |Illegal Combination
+| 1 |1 |1 |0 |Illegal Combination
+| 1 |1 |0 |1 |Illegal Combination
+| 1 |1 |1 |1 |Illegal Combination
+```
+
+- The attacker's ultimate goal is to write special programs or pieces of code that can construct these illegal combinations resulting in an efficient DoS attack.
+
+SYN FLOOD
+
+- The timers (or lack of certain timers) in 3 way handshake are often used and exploited by attackers to disable services or even to enter systems.
+- After step 2 of the three-way handshake, no limit is set on the time to wait after receiving a SYN. The attacker initiates many connection requests to the webserver of Company XYZ (almost certainly with a spoofed IP address).
+- The SYN+ACK packets (Step 2) sent by the web server back to the originating source IP address are not replied to. This leaves a TCP session half-open on the webserver. Multiple packets cause multiple TCP sessions to stay open.
+- Based on the hardware limitations of the server, a limited number of TCP sessions can stay open, and as a result, the webserver refuses further connection establishments attempts from any host as soon as a certain limit is reached. These half-open connections need to be completed or timed out before new connections can be established.
+
+FIN Attack
+
+- In normal operation, the sender sets the TCP FIN flag indicating that no more data will be transmitted and the connection can be closed down.
+- This is a four-way handshake mechanism, with both sender and receiver expected to send an acknowledgement on a received FIN packet.
+
+- During an attack that is trying to kill connections, a spoofed FIN packet is constructed. This packet also has the correct sequence number, so the packets are seen as valid by the targeted host. These sequence numbers are easy to predict. This process is referred to as TCP sequence number prediction, whereby the attacker either sniffs the current Sequence and Acknowledgment (SEQ/ACK) numbers of the connection or can algorithmically predict these numbers.
+
+### Connection Hijacking
+
+ 
+
+- An authorized user (Employee X) sends HTTP requests over a TCP session with the webserver.
+- The web server accepts the packets from Employee X only when the packet has the correct SEQ/ACK numbers. As seen previously, these numbers are important for the webserver to distinguish between different sessions and to make sure it is still talking to Employee X. Imagine that the cracker starts sending packets to the web server spoofing the IP address of Employee X, using the correct SEQ/ACK combination. The web server accepts the packet and increments the ACK number.
+- In the meantime, Employee X continues to send packets but with incorrect SEQ/ACK numbers. As a result of sending unsynchronized packets, all data from Employee X is discarded when received by the webserver. The attacker pretends to be Employee X using the correct numbers. This finally results in the cracker hijacking the connection, whereby Employee X is completely confused and the webserver replies assuming the cracker is sending correct synchronized data.
+
+STEPS:
+
+1. The attacker examines the traffic flows with a network monitor and notices traffic from Employee X to a web server.
+2. The web server returns or echoes data back to the origination station (Employee X).
+3. Employee X acknowledges the packet.
+4. The cracker launches a spoofed packet to the server.
+5. The web server responds to the cracker. The cracker starts verifying SEQ/ACK numbers to double-check success. At this time, the cracker takes over the session from Employee X, which results in a session hanging for Employee X.
+6. The cracker can start sending traffic to the webserver.
+7. The web server returns the requested data to confirm delivery with the correct ACK number.
+8. The cracker can continue to send data (keeping track of the correct SEQ/ACK numbers) until eventually setting the FIN flag to terminate the session.
+
+### Buffer Overflow
+
+- A buffer is a temporary data storage area used to store program code and data.
+- When a program or process tries to store more data in a buffer than it was originally anticipated to hold, a buffer overflow occurs.
+- Buffers are temporary storage locations in memory (memory or buffer sizes are often measured in bytes) that can store a fixed amount of data in bytes. When more data is retrieved than can be stored in a buffer location, the additional information must go into an adjacent buffer, resulting in overwriting the valid data held in them.
+
+
+Mechanism:
+
+- Buffer overflow vulnerabilities exist in different types. But the overall goal for all buffer overflow attacks is to take over the control of a privileged program and, if possible, the host. The attacker has two tasks to achieve this goal. First, the dirty code needs to be available in the program's code address space. Second, the privileged program should jump to that particular part of the code, which ensures that the proper parameters are loaded into memory.
+- The first task can be achieved in two ways: by injecting the code in the right address space or by using the existing code and modifying certain parameters slightly. The second task is a little more complex because the program's control flow needs to be modified to make the program jump to the dirty code.
+
+
+CounterMeasure:
+
+- The most important approach is to have a concerted focus on writing correct code.
+- A second method is to make the data buffers (memory locations) address space of the program code non-executable. This type of address space makes it impossible to execute code, which might be infiltrated in the program's buffers during an attack.
+
+### More Spoofing
+
+Address Resolution Protocol Spoofing
+
+- The Address Resolution Protocol (ARP) provides a mechanism to resolve, or map, a known IP address to a MAC sublayer address.
+- Using ARP spoofing, the cracker can exploit this hardware address authentication mechanism by spoofing the hardware address of Host B. Basically, the attacker can convince any host or network device on the local network that the cracker's workstation is the host to be trusted. This is a common method used in a switched environment.
+ - ARP spoofing can be prevented with the implementation of static ARP tables in all the hosts and routers of your network. Alternatively, you can implement an ARP server that responds to ARP requests on behalf of the target host.
+
+DNS Spoofing
+
+- DNS spoofing is the method whereby the hacker convinces the target machine that the system it wants to connect to is the machine of the cracker.
+- The cracker modifies some records so that name entries of hosts correspond to the attacker's IP address. There have been instances in which the complete DNS server was compromised by an attack.
+- To counter DNS spoofing, the reverse lookup detects these attacks. The reverse lookup is a mechanism to verify the IP address against a name. The IP address and name files are usually kept on different servers to make compromise much more difficult
diff --git a/courses/level101/security/threats_attacks_defences.md b/courses/level101/security/threats_attacks_defences.md
new file mode 100644
index 0000000..145a17d
--- /dev/null
+++ b/courses/level101/security/threats_attacks_defences.md
@@ -0,0 +1,218 @@
+# Part III: Threats, Attacks & Defense
+
+## DNS Protection
+
+### Cache Poisoning Attack
+
+- Since DNS responses are cached, a quick response can be provided for repeated translations.
+DNS negative queries are also cached, e.g., misspelt words, and all cached data periodically times out.
+Cache poisoning is an issue in what is known as pharming. This term is used to describe a hacker’s attack in which a website’s traffic is redirected to a bogus website by forging the DNS mapping. In this case, an attacker attempts to insert a fake address record for an Internet domain into the DNS.
+If the server accepts the fake record, the cache is poisoned and subsequent requests for the address of the domain are answered with the address of a server controlled by the attacker. As long as the fake entry is cached by the server, browsers or e-mail servers will automatically go to the address provided by the compromised DNS server.
+the typical time to live (TTL) for cached entries is a couple of hours, thereby permitting ample time for numerous users to be affected by the attack.
+
+### DNSSEC (Security Extension)
+
+- The long-term solution to these DNS problems is authentication. If a resolver cannot distinguish between valid and invalid data in a response, then add source authentication to verify that the data received in response is equal to the data entered by the zone administrator
+- DNS Security Extensions (DNSSEC) protects against data spoofing and corruption and provides mechanisms to authenticate servers and requests, as well as mechanisms to establish authenticity and integrity.
+- When authenticating DNS responses, each DNS zone signs its data using a private key. It is recommended that this signing be done offline and in advance. The query for a particular record returns the requested resource record set (RRset) and signature (RRSIG) of the requested resource record set. The resolver then authenticates the response using a public key, which is pre-configured or learned via a sequence of key records in the DNS hierarchy.
+- The goals of DNSSEC are to provide authentication and integrity for DNS responses without confidentiality or DDoS protection.
+
+### BGP
+
+- BGP stands for border gateway protocol. It is a routing protocol that exchanges routing information among multiple Autonomous Systems (AS)
+ - An Autonomous System is a collection of routers or networks with the same network policy usually under single administrative control.
+- BGP tells routers which hop to use in order to reach the destination network.
+- BGP is used for both communicating information among routers in an AS (interior) and between multiple ASes (exterior).
+
+ 
+
+## How BGP Works
+
+- BGP is responsible for finding a path to a destination router & the path it chooses should be the shortest and most reliable one.
+- This decision is done through a protocol known as Link state. With the link-state protocol, each router broadcasts to all other routers in the network the state of its links and IP subnets. Each router then receives information from the other routers and constructs a complete topology view of the entire network. The next-hop routing table is based on this topology view.
+- The link-state protocol uses a famous algorithm in the field of computer science, Dijkstra’s shortest path algorithm:
+ - We start from our router considering the path cost to all our direct neighbours.
+ - The shortest path is then taken
+ - We then re-look at all our neighbours that we can reach and update our link state table with the cost information. We then continue taking the shortest path until every router has been visited.
+
+## BGP Vulnerabilities
+
+- By corrupting the BGP routing table we are able to influence the direction traffic flows on the internet! This action is known as BGP hijacking.
+- Injecting bogus route advertising information into the BGP-distributed routing database by malicious sources, accidentally or routers can disrupt Internet backbone operations.
+- Blackholing traffic:
+ - Blackhole route is a network route, i.e., routing table entry, that goes nowhere and packets matching the route prefix are dropped or ignored. Blackhole routes can only be detected by monitoring the lost traffic.
+ - Blackhole routes are the best defence against many common viral attacks where the traffic is dropped from infected machines to/from command & control hosts.
+ - Infamous BGP Injection attack on Youtube
+
+- Ex: In 2008, Pakistan decided to block YouTube by creating a BGP route that led into a black hole. Instead, this routing information got transmitted to a hong kong ISP and from there accidentally got propagated to the rest of the world meaning millions were routed through to this black hole and therefore unable to access YouTube.
+- Potentially, the greatest risk to BGP occurs in a denial of service attack in which a router is flooded with more packets than it can handle. Network overload and router resource exhaustion happen when the network begins carrying an excessive number of BGP messages, overloading the router control processors, memory, routing table and reducing the bandwidth available for data traffic.
+- Refer:
+- Router flapping is another type of attack. Route flapping refers to repetitive changes to the BGP routing table, often several times a minute. Withdrawing and re-advertising at a high-rate can cause a serious problem for routers since they propagate the announcements of routes. If these route flaps happen fast enough, e.g., 30 to 50 times per second, the router becomes overloaded, which eventually prevents convergence on valid routes. The potential impact for Internet users is a slowdown in message delivery, and in some cases, packets may not be delivered at all.
+
+BGP Security
+
+- Border Gateway Protocol Security recommends the use of BGP peer authentication since it is one of the strongest mechanisms for preventing malicious activity.
+ - The authentication mechanisms are Internet Protocol Security (IPsec) or BGP MD5.
+- Another method, known as prefix limits, can be used to avoid filling router tables. In this approach, routers should be configured to disable or terminate a BGP peering session, and issue warning messages to administrators when a neighbour sends in excess of a preset number of prefixes.
+- IETF is currently working on improving this space
+
+## Web-Based Attacks
+
+### HTTP Response Splitting Attacks
+
+- HTTP response splitting attack may happen where the server script embeds user data in HTTP response headers without appropriate sanitation.
+- This typically happens when the script embeds user data in the redirection URL of a redirection response (HTTP status code 3xx), or when the script embeds user data in a cookie value or name when the response sets a cookie.
+- HTTP response splitting attacks can be used to perform web cache poisoning and cross-site scripting attacks.
+- HTTP response splitting is the attacker’s ability to send a single HTTP request that forces the webserver to form an output stream, which is then interpreted by the target as two HTTP responses instead of one response.
+
+### Cross-Site Request Forgery (CSRF or XSRF)
+
+- A Cross-Site Request Forgery attack tricks the victim’s browser into issuing a command to a vulnerable web application.
+- Vulnerability is caused by browsers automatically including user authentication data, session ID, IP address, Windows domain credentials, etc. with each request.
+- Attackers typically use CSRF to initiate transactions such as transfer funds, login/logout user, close account, access sensitive data, and change account details.
+- The vulnerability is caused by web browsers that automatically include credentials with each request, even for requests caused by a form, script, or image on another site. CSRF can also be dynamically constructed as part of a payload for a cross-site scripting attack
+- All sites relying on automatic credentials are vulnerable. Popular browsers cannot prevent cross-site request forgery. Logging out of high-value sites as soon as possible can mitigate CSRF risk. It is recommended that a high-value website must require a client to manually provide authentication data in the same HTTP request used to perform any operation with security implications. Limiting the lifetime of session cookies can also reduce the chance of being used by other malicious sites.
+- OWASP recommends website developers include a required security token in HTTP requests associated with sensitive business functions in order to mitigate CSRF attacks
+
+### Cross-Site Scripting (XSS) Attacks
+
+- Cross-Site Scripting occurs when dynamically generated web pages display user input, such as login information, that is not properly validated, allowing an attacker to embed malicious scripts into the generated page and then execute the script on the machine of any user that views the site.
+- If successful, Cross-Site Scripting vulnerabilities can be exploited to manipulate or steal cookies, create requests that can be mistaken for those of a valid user, compromise confidential information, or execute malicious code on end-user systems.
+- Cross-Site Scripting (XSS or CSS) attacks involve the execution of malicious scripts on the victim’s browser. The victim is simply a user’s host and not the server. XSS results from a failure to validate user input by a web-based application.
+
+### Document Object Model (DOM) XSS Attacks
+
+- The Document Object Model (DOM) based XSS does not require the webserver to receive the XSS payload for a successful attack. The attacker abuses the runtime by embedding their data on the client-side. An attacker can force the client (browser) to render the page with parts of the DOM controlled by the attacker.
+- When the page is rendered and the data is processed by the page, typically by a client-side HTML-embedded script such as JavaScript, the page’s code may insecurely embed the data in the page itself, thus delivering the cross-site scripting payload. There are several DOM objects which can serve as an attack vehicle for delivering malicious script to victims browser.
+
+### Clickjacking
+
+- The technique works by hiding malicious link/scripts under the cover of the content of a legitimate site.
+- Buttons on a website actually contain invisible links, placed there by the attacker. So, an individual who clicks on an object they can visually see is actually being duped into visiting a malicious page or executing a malicious script.
+- When mouseover is used together with clickjacking, the outcome is devastating. Facebook users have been hit by a clickjacking attack, which tricks people into “liking” a particular Facebook page, thus enabling the attack to spread since Memorial Day 2010.
+- There is not yet effective defence against clickjacking, and disabling JavaScript is the only viable method
+
+## DataBase Attacks & Defenses
+
+### SQL injection Attacks
+
+- It exploits improper input validation in database queries.
+- A successful exploit will allow attackers to access, modify, or delete information in the database.
+- It permits attackers to steal sensitive information stored within the backend databases of affected websites, which may include such things as user credentials, email addresses, personal information, and credit card numbers
+
+```
+SELECT USERNAME,PASSWORD from USERS where USERNAME='' AND PASSWORD='';
+
+Here the username & password is the input provided by the user. Suppose an attacker gives the input as " OR '1'='1'" in both fields. Therefore the SQL query will look like:
+
+SELECT USERNAME,PASSWORD from USERS where USERNAME='' OR '1'='1' AND PASSOWRD='' OR '1'='1';
+
+This query results in a true statement & the user gets logged in. This example depicts the bost basic type of SQL injection
+```
+
+
+### SQL Injection Attack Defenses
+
+- SQL injection can be protected by filtering the query to eliminate malicious syntax, which involves the employment of some tools in order to (a) scan the source code.
+- In addition, the input fields should be restricted to the absolute minimum, typically anywhere from 7-12 characters, and validate any data, e.g., if a user inputs an age make sure the input is an integer with a maximum of 3 digits.
+
+## VPN
+
+A virtual private network (VPN) is a service that offers a secure, reliable connection over a shared public infrastructure such as the Internet. Cisco defines a VPN as an encrypted connection between private networks over a public network. To date, there are three types of VPNs:
+
+- Remote access
+- Site-to-site
+- Firewall-based
+
+## Security Breach
+
+In spite of the most aggressive steps to protect computers from attacks, attackers sometimes get through. Any event that results in a violation of any of the confidentiality, integrity, or availability (CIA) security tenets is a security breach.
+
+### Denial of Service Attacks
+
+- Denial of service (DoS) attacks result in downtime or inability of a user to access a system. DoS attacks impact the availability of tenet of information systems security. A DoS attack is a coordinated attempt to deny service by occupying a computer to perform large amounts of unnecessary tasks. This excessive activity makes the system unavailable to perform legitimate operations
+- Two common types of DoS attacks are as follows:
+ - Logic attacks—Logic attacks use software flaws to crash or seriously hinder the performance of remote servers. You can prevent many of these attacks by installing the latest patches to keep your software up to date.
+ - Flooding attacks—Flooding attacks overwhelm the victim computer’s CPU, memory, or network resources by sending large numbers of useless requests to the machine.
+- Most DoS attacks target weaknesses in the overall system architecture rather than a software bug or security flaw
+- One popular technique for launching a packet flood is a SYN flood.
+- One of the best defences against DoS attacks is to use intrusion prevention system (IPS) software or devices to detect and stop the attack.
+
+### Distributed Denial of Service Attacks
+
+- DDoS attacks differ from regular DoS attacks in their scope. In a DDoS attack, attackers hijack hundreds or even thousands of Internet computers, planting automated attack agents on those systems. The attacker then instructs the agents to bombard the target site with forged messages. This overloads the site and blocks legitimate traffic. The key here is strength in numbers. The attacker does more damage by distributing the attack across multiple computers.
+
+
+### Wiretapping
+
+- Although the term wiretapping is generally associated with voice telephone communications, attackers can also use wiretapping to intercept data communications.
+
+- Attackers can tap telephone lines and data communication lines. Wiretapping can be active, where the attacker makes modifications to the line. It can also be passive, where an unauthorized user simply listens to the transmission without changing the contents. Passive intrusion can include the copying of data for a subsequent active attack.
+- Two methods of active wiretapping are as follows:
+ - Between-the-lines wiretapping—This type of wiretapping does not alter the messages sent by the legitimate user but inserts additional messages into the communication line when the legitimate user pauses.
+ - Piggyback-entry wiretapping—This type of wiretapping intercepts and modifies the original message by breaking the communications line and routing the message to another computer that acts as a host.
+
+### Backdoors
+
+- Software developers sometimes include hidden access methods, called backdoors, in their programs. Backdoors give developers or support personnel easy access to a system without having to struggle with security controls. The problem is that backdoors don’t always stay hidden. When an attacker discovers a backdoor, he or she can use it to bypass existing security controls such as passwords, encryption, and so on. Where legitimate users log on through front doors using a user ID and password, attackers use backdoors to bypass these normal access controls.
+
+## Malicious Attacks
+
+### Birthday Attack
+
+- Once an attacker compromises a hashed password file, a birthday attack is performed. A birthday attack is a type of cryptographic attack that is used to make a brute-force attack of one-way hashes easier. It is a mathematical exploit that is based on the birthday problem in probability theory.
+- Further Reading:
+ -
+ -
+
+### Brute-Force Password Attacks
+
+- In a brute-force password attack, the attacker tries different passwords on a system until one of them is successful. Usually, the attacker employs a software program to try all possible combinations of a likely password, user ID, or security code until it locates a match. This occurs rapidly and in sequence. This type of attack is called a brute-force password attack because the attacker simply hammers away at the code. There is no skill or stealth involved—just brute force that eventually breaks the code.
+- Further Reading:
+ -
+ -
+
+### Dictionary Password Attacks
+
+- A dictionary password attack is a simple attack that relies on users making poor password choices. In a dictionary password attack, a simple password-cracker program takes all the words from a dictionary file and attempts to log on by entering each dictionary entry as a password.
+- Further Reading:
+https://capec.mitre.org/data/definitions/16.html
+
+### Replay Attacks
+
+- Replay attacks involve capturing data packets from a network and retransmitting them to produce an unauthorized effect. The receipt of duplicate, authenticated IP packets may disrupt service or have some other undesired consequence. Systems can be broken through replay attacks when attackers reuse old messages or parts of old messages to deceive system users. This helps intruders to gain information that allows unauthorized access into a system.
+- Further reading:
+
+
+### Man-in-the-Middle Attacks
+
+- A man-in-the-middle attack takes advantage of the multihop process used by many types of networks. In this type of attack, an attacker intercepts messages between two parties before transferring them on to their intended destination.
+- Web spoofing is a type of man-in-the-middle attack in which the user believes a secure session exists with a particular web server. In reality, the secure connection exists only with the attacker, not the webserver. The attacker then establishes a secure connection with the webserver, acting as an invisible go-between. The attacker passes traffic between the user and the webserver. In this way, the attacker can trick the user into supplying passwords, credit card information, and other private data.
+- Further Reading:
+ -
+
+### Masquerading
+
+- In a masquerade attack, one user or computer pretends to be another user or computer. Masquerade attacks usually include one of the other forms of active attacks, such as IP address spoofing or replaying. Attackers can capture authentication sequences and then replay them later to log on again to an application or operating system. For example, an attacker might monitor usernames and passwords sent to a weak web application. The attacker could then use the intercepted credentials to log on to the web application and impersonate the user.
+- Further Reading:
+
+
+### Eavesdropping
+
+- Eavesdropping, or sniffing, occurs when a host sets its network interface on promiscuous mode and copies packets that pass by for later analysis. Promiscuous mode enables a network device to intercept and read each network packet(of course given some conditions) given sec, even if the packet’s address doesn’t match the network device. It is possible to attach hardware and software to monitor and analyze all packets on that segment of the transmission media without alerting any other users. Candidates for eavesdropping include satellite, wireless, mobile, and other transmission methods.
+
+### Social Engineering
+
+- Attackers often use a deception technique called social engineering to gain access to resources in an IT infrastructure. In nearly all cases, social engineering involves tricking authorized users into carrying out actions for unauthorized users. The success of social engineering attacks depends on the basic tendency of people to want to be helpful.
+
+### Phreaking
+
+- Phone phreaking, or simply phreaking, is a slang term that describes the activity of a subculture of people who study, experiment with, or explore telephone systems, telephone company equipment, and systems connected to public telephone networks. Phreaking is the art of exploiting bugs and glitches that exist in the telephone system.
+
+### Phishing
+
+- Phishing is a type of fraud in which an attacker attempts to trick the victim into providing private information such as credit card numbers, passwords, dates of birth, bank account numbers, automated teller machine (ATM) PINs, and Social Security numbers.
+
+### Pharming
+
+- Pharming is another type of attack that seeks to obtain personal or private financial information through domain spoofing. A pharming attack doesn’t use messages to trick victims into visiting spoofed websites that appear legitimate, however. Instead, pharming “poisons” a domain name on the domain name server (DNS), a process known as DNS poisoning. The result is that when a user enters the poisoned server’s web address into his or her address bar, that user navigates to the attacker’s site. The user’s browser still shows the correct website, which makes pharming difficult to detect—and therefore more serious. Where phishing attempts to scam people one at a time with an email or instant message, pharming enables scammers to target large groups of people at one time through domain spoofing.
diff --git a/courses/level101/security/writing_secure_code.md b/courses/level101/security/writing_secure_code.md
new file mode 100644
index 0000000..8be7b8c
--- /dev/null
+++ b/courses/level101/security/writing_secure_code.md
@@ -0,0 +1,56 @@
+# PART IV: Writing Secure Code & More
+
+The first and most important step in reducing security and reliability issues is to educate developers. However, even the best-trained engineers make mistakes, security experts can write insecure code and SREs can miss reliability issues. It’s difficult to keep the many considerations and tradeoffs involved in building secure and reliable systems in mind simultaneously, especially if you’re also responsible for producing software.
+
+## Use frameworks to enforce security and reliability while writing code
+
+- A better approach is to handle security and reliability in common frameworks, languages, and libraries. Ideally, libraries only expose an interface that makes writing code with common classes of security vulnerabilities impossible.
+- Multiple applications can use each library or framework. When domain experts fix an issue, they remove it from all the applications the framework supports, allowing this engineering approach to scale better.
+
+## Common Security Vulnerabilities
+
+- In large codebases, a handful of classes account for the majority of security vulnerabilities, despite ongoing efforts to educate developers and introduce code review. OWASP and SANS publish lists of common vulnerability classes
+
+ 
+
+## Write Simple Code
+
+ Try to keep your code clean and simple.
+
+### Avoid Multi-Level Nesting
+
+- Multilevel nesting is a common anti-pattern that can lead to simple mistakes. If the error is in the most common code path, it will likely be captured by the unit tests. However, unit tests don’t always check error handling paths in multilevel nested code. The error might result in decreased reliability (for example, if the service crashes when it mishandles an error) or a security vulnerability (like a mishandled authorization check error).
+
+### Eliminate YAGNI Smells
+
+- Sometimes developers overengineer solutions by adding functionality that may be useful in the future, “just in case.” This goes against the YAGNI (You Aren’t Gonna Need It) principle, which recommends implementing only the code that you need. YAGNI code adds unnecessary complexity because it needs to be documented, tested, and maintained.
+- To summarize, avoiding YAGNI code leads to improved reliability, and simpler code leads to fewer security bugs, fewer opportunities to make mistakes, and less developer time spent maintaining unused code.
+
+### Repay Technical Debt
+
+- It is a common practice for developers to mark places that require further attention with TODO or FIXME annotations. In the short term, this habit can accelerate the delivery velocity for the most critical functionality, and allow a team to meet early deadlines—but it also incurs technical debt. Still, it’s not necessarily a bad practice, as long as you have a clear process (and allocate time) for repaying such debt.
+
+### Refactoring
+
+- Refactoring is the most effective way to keep a codebase clean and simple. Even a healthy codebase occasionally needs to be
+- Regardless of the reasons behind refactoring, you should always follow one golden rule: never mix refactoring and functional changes in a single commit to the code repository. Refactoring changes are typically significant and can be difficult to understand.
+- If a commit also includes functional changes, there’s a higher risk that an author or reviewer might overlook bugs.
+
+### Unit Testing
+
+- Unit testing can increase system security and reliability by pinpointing a wide range of bugs in individual software components before a release. This technique involves breaking software components into smaller, self-contained “units” that have no external dependencies, and then testing each unit.
+
+### Fuzz Testing
+
+- Fuzz testing is a technique that complements the previously mentioned testing techniques. Fuzzing involves using a fuzzing engine to generate a large number of candidate inputs that are then passed through a fuzz driver to the fuzz target. The fuzzer then analyzes how the system handles the input. Complex inputs handled by all kinds of software are popular targets for fuzzing - for example, file parsers, compression algorithms, network protocol implementation and audio codec.
+
+### Integration Testing
+
+- Integration testing moves beyond individual units and abstractions, replacing fake or stubbed-out implementations of abstractions like databases or network services with real implementations. As a result, integration tests exercise more complete code paths. Because you must initialize and configure these other dependencies, integration testing may be slower and flakier than unit testing—to execute the test, this approach incorporates real-world variables like network latency as services communicate end-to-end. As you move from testing individual low-level units of code to testing how they interact when composed together, the net result is a higher degree of confidence that the system is behaving as expected.
+
+### Last But not the least
+
+- Code Reviews
+- Rely on Automation
+- Don’t check in Secrets
+- Verifiable Builds
diff --git a/courses/systems_design/availability.md b/courses/systems_design/availability.md
new file mode 100644
index 0000000..87410c4
--- /dev/null
+++ b/courses/systems_design/availability.md
@@ -0,0 +1,89 @@
+# HA - Availability - Common “Nines”
+Availability is generally expressed as “Nines”, common ‘Nines’ are listed below.
+
+| Availability % | Downtime per year | Downtime per month | Downtime per week | Downtime per day |
+|---------------------------------|:-----------------:|:-------------------:|:-----------------:|:----------------:|
+| 99%(Two Nines) | 3.65 days | 7.31 hours | 1.68 hours | 14.40 minutes |
+| 99.5%(Two and a half Nines) | 1.83 days | 3.65 hours | 50.40 minutes | 7.20 minutes |
+| 99.9%(Three Nines) | 8.77 hours | 43.83 minutes | 10.08 minutes | 1.44 minutes |
+| 99.95%(Three and a half Nines) | 4.38 hours | 21.92 minutes | 5.04 minutes | 43.20 seconds |
+| 99.99%(Four Nines) | 52.60 minutes | 4.38 minutes | 1.01 minutes | 8.64 seconds |
+| 99.995%(Four and a half Nines) | 26.30 minutes | 2.19 minutes | 30.24 seconds | 4.32 seconds |
+| 99.999%(Five Nines) | 5.26 minutes | 26.30 seconds | 6.05 seconds | 864.0 ms |
+
+### Refer
+- https://en.wikipedia.org/wiki/High_availability#Percentage_calculation
+
+## HA - Availability Serial Components
+
+A System with components is operating in the series If the failure of a part leads to the combination becoming inoperable.
+
+For example, if LB in our architecture fails, all access to app tiers will fail. LB and app tiers are connected serially.
+
+
+The combined availability of the system is the product of individual components availability
+
+*A = Ax x Ay x …..*
+
+### Refer
+- http://www.eventhelix.com/RealtimeMantra/FaultHandling/system_reliability_availability.htm
+
+## HA - Availability Parallel Components
+
+A System with components is operating in parallel If the failure of a part leads to the other part taking over the operations of the failed part.
+
+If we have more than one LB and if the rest of the LBs can take over the traffic during one LB failure then LBs are operating in parallel
+
+The combined availability of the system is
+
+*A = 1 - ( (1-Ax) x (1-Ax) x ….. )*
+
+### Refer
+- http://www.eventhelix.com/RealtimeMantra/FaultHandling/system_reliability_availability.htm
+
+## HA - Core Principles
+
+**Elimination of single points of failure (SPOF)** This means adding redundancy to the system so that the failure of a component does not mean failure of the entire system.
+
+**Reliable crossover** In redundant systems, the crossover point itself tends to become a single point of failure. Reliable systems must provide for reliable crossover.
+
+**Detection of failures as they occur** If the two principles above are observed, then a user may never see a failure
+
+### Refer
+- https://en.wikipedia.org/wiki/High_availability#Principles
+
+## HA - SPOF
+
+**WHAT:** Never implement and always eliminate single points of failure.
+
+**WHEN TO USE:** During architecture reviews and new designs.
+
+**HOW TO USE:** Identify single instances on architectural diagrams. Strive for active/active configurations. At the very least we should have a standby to take control when active instances fail.
+
+**WHY:** Maximize availability through multiple instances.
+
+**KEY TAKEAWAYS:** Strive for active/active rather than active/passive solutions. Use load balancers to balance traffic across instances of a service. Use control services with active/passive instances for patterns that require singletons.
+
+## HA - Reliable Crossover
+
+**WHAT:** Ensure when system components failover they do so reliably.
+
+**WHEN TO USE:** During architecture reviews, failure modeling, and designs.
+
+**HOW TO USE:** Identify how available a system is during the crossover and ensure it is within acceptable limits.
+
+**WHY:** Maximize availability and ensure data handling semantics are preserved.
+
+**KEY TAKEAWAYS:** Strive for active/active rather than active/passive solutions, they have a lesser risk of cross over being unreliable. Use LB and the right load balancing methods to ensure reliable failover. Model and build your data systems to ensure data is correctly handled when crossover happens. Generally, DB systems follow active/passive semantics for writes. Masters accept writes and when the master goes down, the follower is promoted to master(active from being passive) to accept writes. We have to be careful here that the cutover never introduces more than one master. This problem is called a split brain.
+
+## Applications in SRE role
+
+1. SRE works on deciding an acceptable SLA and make sure the system is available to achieve the SLA
+2. SRE is involved in architecture design right from building the data center to make sure the site is not affected by a network switch, hardware, power, or software failures
+3. SRE also run mock drills of failures to see how the system behaves in uncharted territory and comes up with a plan to improve availability if there are misses.
+https://engineering.linkedin.com/blog/2017/11/resilience-engineering-at-linkedin-with-project-waterbear
+
+
+Post our understanding about HA, our architecture diagram looks something like this below
+
+
diff --git a/courses/systems_design/conclusion.md b/courses/systems_design/conclusion.md
new file mode 100644
index 0000000..8e3cb47
--- /dev/null
+++ b/courses/systems_design/conclusion.md
@@ -0,0 +1,3 @@
+# Conclusion
+
+Armed with these principles, we hope the course will give a fresh perspective to design software systems. It might be over-engineering to get all this on day zero. But some are really important from day 0 like eliminating single points of failure, making scalable services by just increasing replicas. As a bottleneck is reached, we can split code by services, shard data to scale. As the organization matures, bringing in [chaos engineering](https://en.wikipedia.org/wiki/Chaos_engineering) to measure how systems react to failure will help in designing robust software systems.
diff --git a/courses/systems_design/fault-tolerance.md b/courses/systems_design/fault-tolerance.md
new file mode 100644
index 0000000..2ff9cd6
--- /dev/null
+++ b/courses/systems_design/fault-tolerance.md
@@ -0,0 +1,66 @@
+# Fault Tolerance
+
+Failures are not avoidable in any system and will happen all the time, hence we need to build systems that can tolerate failures or recover from them.
+
+- In systems, failure is the norm rather than the exception.
+- "Anything that can go wrong will go wrong” -- Murphy’s Law
+- “Complex systems contain changing mixtures of failures latent within them” -- How Complex Systems Fail.
+
+### Fault Tolerance - Failure Metrics
+
+Common failure metrics that get measured and tracked for any system.
+
+**Mean time to repair (MTTR):** The average time to repair and restore a failed system.
+
+**Mean time between failures (MTBF):** The average operational time between one device failure or system breakdown and the next.
+
+**Mean time to failure (MTTF):** The average time a device or system is expected to function before it fails.
+
+**Mean time to detect (MTTD):** The average time between the onset of a problem and when the organization detects it.
+
+**Mean time to investigate (MTTI):** The average time between the detection of an incident and when the organization begins to investigate its cause and solution.
+
+**Mean time to restore service (MTRS):** The average elapsed time from the detection of an incident until the affected system or component is again available to users.
+
+**Mean time between system incidents (MTBSI):** The average elapsed time between the detection of two consecutive incidents. MTBSI can be calculated by adding MTBF and MTRS (MTBSI = MTBF + MTRS).
+
+**Failure rate:** Another reliability metric, which measures the frequency with which a component or system fails. It is expressed as a number of failures over a unit of time.
+
+#### Refer
+- https://www.splunk.com/en_us/data-insider/what-is-mean-time-to-repair.html
+
+### Fault Tolerance - Fault Isolation Terms
+Systems should have a short circuit. Say in our content sharing system, if “Notifications” is not working, the site should gracefully handle that failure by removing the functionality instead of taking the whole site down.
+
+Swimlane is one of the commonly used fault isolation methodologies. Swimlane adds a barrier to the service from other services so that failure on either of them won’t affect the other. Say we roll out a new feature ‘Advertisement’ in our content sharing app.
+We can have two architectures
+
+
+If Ads are generated on the fly synchronously during each Newsfeed request, the faults in the Ads feature get propagated to the Newsfeed feature. Instead if we swimlane the “Generation of Ads” service and use a shared storage to populate Newsfeed App, Ads failures won’t cascade to Newsfeed, and worst case if Ads don’t meet SLA , we can have Newsfeed without Ads.
+
+Let's take another example, we have come up with a new model for our Content sharing App. Here we roll out an enterprise content sharing App where enterprises pay for the service and the content should never be shared outside the enterprise.
+
+
+
+### Swimlane Principles
+
+**Principle 1:** Nothing is shared (also known as “share as little as possible”). The less that is shared within a swim lane, the more fault isolative the swim lane becomes. (as shown in Enterprise use-case)
+
+**Principle 2:** Nothing crosses a swim lane boundary. Synchronous (defined by expecting a request—not the transfer protocol) communication never crosses a swim lane boundary; if it does, the boundary is drawn incorrectly. (as shown in Ads feature)
+
+### Swimlane Approaches
+**Approach 1:** Swim lane the money-maker. Never allow your cash register to be compromised by other systems. (Tier 1 vs Tier 2 in enterprise use case)
+
+**Approach 2:** Swim lane the biggest sources of incidents. Identify the recurring causes of pain and isolate them. (if Ads feature is in code yellow, swim laning it is the best option)
+
+**Approach 3:** Swim lane natural barriers. Customer boundaries make good swim lanes. (Public vs Enterprise customers)
+
+
+#### Refer
+- https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch21.html#ch21
+
+
+### Applications in SRE role
+1. Work with the DC tech or cloud team to distribute infrastructure such that its immune to switch or power failures by creating fault zones within a Data Center
+https://docs.microsoft.com/en-us/azure/virtual-machines/manage-availability#use-availability-zones-to-protect-from-datacenter-level-failures
+2. Work with the partners and design interaction between services such that one service breakdown is not amplified in a cascading fashion to all upstreams
diff --git a/courses/systems_design/images/availability.jpg b/courses/systems_design/images/availability.jpg
new file mode 100644
index 0000000..7921e59
Binary files /dev/null and b/courses/systems_design/images/availability.jpg differ
diff --git a/courses/systems_design/images/cdn.jpg b/courses/systems_design/images/cdn.jpg
new file mode 100644
index 0000000..1be88eb
Binary files /dev/null and b/courses/systems_design/images/cdn.jpg differ
diff --git a/courses/systems_design/images/first-architecture.jpg b/courses/systems_design/images/first-architecture.jpg
new file mode 100644
index 0000000..999f069
Binary files /dev/null and b/courses/systems_design/images/first-architecture.jpg differ
diff --git a/courses/systems_design/images/horizontal-scaling.jpg b/courses/systems_design/images/horizontal-scaling.jpg
new file mode 100644
index 0000000..8957110
Binary files /dev/null and b/courses/systems_design/images/horizontal-scaling.jpg differ
diff --git a/courses/systems_design/images/microservices.jpg b/courses/systems_design/images/microservices.jpg
new file mode 100644
index 0000000..10ade7c
Binary files /dev/null and b/courses/systems_design/images/microservices.jpg differ
diff --git a/courses/systems_design/images/sharding-1.jpg b/courses/systems_design/images/sharding-1.jpg
new file mode 100644
index 0000000..b967670
Binary files /dev/null and b/courses/systems_design/images/sharding-1.jpg differ
diff --git a/courses/systems_design/images/sharding-2.jpg b/courses/systems_design/images/sharding-2.jpg
new file mode 100644
index 0000000..7b1bc88
Binary files /dev/null and b/courses/systems_design/images/sharding-2.jpg differ
diff --git a/courses/systems_design/images/swimlane-1.jpg b/courses/systems_design/images/swimlane-1.jpg
new file mode 100644
index 0000000..7878f0c
Binary files /dev/null and b/courses/systems_design/images/swimlane-1.jpg differ
diff --git a/courses/systems_design/images/swimlane-2.jpg b/courses/systems_design/images/swimlane-2.jpg
new file mode 100644
index 0000000..c68d4d1
Binary files /dev/null and b/courses/systems_design/images/swimlane-2.jpg differ
diff --git a/courses/systems_design/intro.md b/courses/systems_design/intro.md
new file mode 100644
index 0000000..802a05a
--- /dev/null
+++ b/courses/systems_design/intro.md
@@ -0,0 +1,49 @@
+# Systems Design
+
+## Prerequisites
+
+Fundamentals of common software system components:
+
+- [Linux Basics](https://linkedin.github.io/school-of-sre/level101/linux_basics/intro/)
+- [Linux Networking](https://linkedin.github.io/school-of-sre/level101/linux_networking/intro/)
+- Databases RDBMS
+- [NoSQL Concepts](https://linkedin.github.io/school-of-sre/level101/databases_nosql/intro/)
+
+## What to expect from this course
+
+Thinking about and designing for scalability, availability, and reliability of large scale software systems.
+
+## What is not covered under this course
+
+Individual software components’ scalability and reliability concerns like e.g. Databases, while the same scalability principles and thinking can be applied, these individual components have their own specific nuances when scaling them and thinking about their reliability.
+
+More light will be shed on concepts rather than on setting up and configuring components like Loadbalancers to achieve scalability, availability, and reliability of systems
+
+## Course Contents
+
+- [Introduction](https://linkedin.github.io/school-of-sre/level101/systems_design/intro/#backstory)
+- [Scalability](https://linkedin.github.io/school-of-sre/level101/systems_design/scalability/)
+- [High Availability](https://linkedin.github.io/school-of-sre/level101/systems_design/availability/)
+- [Fault Tolerance](https://linkedin.github.io/school-of-sre/level101/systems_design/fault-tolerance/)
+
+
+## Introduction
+
+So, how do you go about learning to design a system?
+
+*” Like most great questions, it showed a level of naivety that was breathtaking. The only short answer I could give was, essentially, that you learned how to design a system by designing systems and finding out what works and what doesn’t work.”
+Jim Waldo, Sun Microsystems, On System Design*
+
+
+As software and hardware systems have multiple moving parts, we need to think about how those parts will grow, their failure modes, their inter-dependencies, how it will impact the users and the business.
+
+There is no one-shot method or way to learn or do system design, we only learn to design systems by designing and iterating on them.
+
+This course will be a starter to make one think about scalability, availability, and fault tolerance during systems design.
+
+## Backstory
+
+Let’s design a simple content sharing application where users can share photos, media in our application which can be liked by their friends. Let’s start with a simple design of the application and evolve it as we learn system design concepts
+
+
+
diff --git a/courses/systems_design/scalability.md b/courses/systems_design/scalability.md
new file mode 100644
index 0000000..a69ff2c
--- /dev/null
+++ b/courses/systems_design/scalability.md
@@ -0,0 +1,183 @@
+# Scalability
+What does scalability mean for a system/service? A system is composed of services/components, each service/component scalability needs to be tackled separately, and the scalability of the system as a whole.
+
+A service is said to be scalable if, as resources are added to the system, it results in increased performance in a manner proportional to resources added
+
+An always-on service is said to be scalable if adding resources to facilitate redundancy does not result in a loss of performance
+
+## Refer
+- [https://www.allthingsdistributed.com/2006/03/a_word_on_scalability.html](https://www.allthingsdistributed.com/2006/03/a_word_on_scalability.html)
+
+
+## Scalability - AKF Scale Cube
+
+The [Scale Cube](https://akfpartners.com/growth-blog/scale-cube) is a model for segmenting services, defining microservices, and scaling products. It also creates a common language for teams to discuss scale related options in designing solutions. The following section talks about certain scaling patterns based on our inferences from the AKF cube
+
+## Scalability - Horizontal scaling
+
+Horizontal scaling stands for cloning of an application or service such that work can easily be distributed across instances with absolutely no bias.
+
+Let's see how our monolithic application improves with this principle
+
+
+
+Here DB is scaled separately from the application. This is to let you know each component’s scaling capabilities can be different. Usually, web applications can be scaled by adding resources unless there is state stored inside the application. But DBs can be scaled only for Reads by adding more followers but Writes have to go to only one leader to make sure data is consistent. There are some DBs that support multi-leader writes but we are keeping them out of scope at this point.
+
+Apps should be able to differentiate between Reads and Writes to choose appropriate DB servers. Load balancers can split traffic between identical servers transparently.
+
+**WHAT:** Duplication of services or databases to spread transaction load.
+
+**WHEN TO USE:** Databases with a very high read-to-write ratio (5:1 or greater—the higher the better). Because only read replicas of DBs can be scaled, not the Leader.
+
+**HOW TO USE:** Simply clone services and implement a load balancer. For databases, ensure that the accessing code understands the difference between a read and a write.
+
+**WHY:** Allows for the fast scale of transactions at the cost of duplicated data and functionality.
+
+**KEY TAKEAWAYS:** This is fast to implement, is a low cost from a developer effort perspective, and can scale transaction volumes nicely. However, they tend to be high cost from the perspective of the operational cost of data. The cost here means if we have 3 followers and 1 Leader DB, the same database will be stored as 4 copies in the 4 servers. Hence added storage cost
+
+### Refer
+- [https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html](https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html)
+
+### Scalability Pattern - Load Balancing
+
+Improves the distribution of workloads across multiple computing resources, such as computers, a computer cluster, network links, central processing units, or disk drives. A commonly used technique is load balancing traffic across identical server clusters. A similar philosophy is used to load balance traffic across network links by [ECMP](https://en.wikipedia.org/wiki/Equal-cost_multi-path_routing), disk drives by [RAID](https://en.wikipedia.org/wiki/RAID),etc
+
+Aims to optimize resource use, maximize throughput, minimize response time, and avoid overload of any single resource.
+Using multiple components with load balancing instead of a single component may increase reliability and availability through redundancy. In our updated architecture diagram we have 4 servers to handle app traffic instead of a single server
+
+The device or system that performs load balancing is called a load balancer, abbreviated as LB.
+
+#### Refer
+- [https://en.wikipedia.org/wiki/Load_balancing_(computing)](https://en.wikipedia.org/wiki/Load_balancing_(computing))
+- [https://blog.envoyproxy.io/introduction-to-modern-network-load-balancing-and-proxying-a57f6ff80236](https://blog.envoyproxy.io/introduction-to-modern-network-load-balancing-and-proxying-a57f6ff80236)
+- [https://learning.oreilly.com/library/view/load-balancing-in/9781492038009/](https://learning.oreilly.com/library/view/load-balancing-in/9781492038009/)
+- [https://learning.oreilly.com/library/view/practical-load-balancing/9781430236801/](https://learning.oreilly.com/library/view/practical-load-balancing/9781430236801/)
+- [http://shop.oreilly.com/product/9780596000509.do](http://shop.oreilly.com/product/9780596000509.do)
+
+### Scalability Pattern - LB Tasks
+
+What does an LB do?
+
+
+#### Service discovery:
+What backends are available in the system? In our architecture, 4 servers are available to serve App traffic. LB acts as a single endpoint that clients can use transparently to reach one of the 4 servers.
+
+#### Health checking:
+What backends are currently healthy and available to accept requests? If one out of the 4 App servers turns bad, LB should automatically short circuit the path so that clients don’t sense any application downtime
+
+#### Load balancing:
+What algorithm should be used to balance individual requests across the healthy backends? There are many algorithms to distribute traffic across one of the four servers. Based on observations/experience, SRE can pick the algorithm that suits their pattern
+
+### Scalability Pattern - LB Methods
+Common Load Balancing Methods
+
+#### Least Connection Method
+directs traffic to the server with the fewest active connections. Most useful when there are a large number of persistent connections in the traffic unevenly distributed between the servers. Works if clients maintain long-lived connections
+
+#### Least Response Time Method
+directs traffic to the server with the fewest active connections and the lowest average response time. Here response time is used to provide feedback of the server’s health
+
+#### Round Robin Method
+rotates servers by directing traffic to the first available server and then moves that server to the bottom of the queue. Most useful when servers are of equal specification and there are not many persistent connections.
+
+#### IP Hash
+the IP address of the client determines which server receives the request. This can sometimes cause skewness in distribution but is useful if apps store some state locally and need some stickiness
+
+More advanced client/server-side example techniques
+- https://docs.nginx.com/nginx/admin-guide/load-balancer/
+- http://cbonte.github.io/haproxy-dconv/2.2/intro.html#3.3.5
+- https://twitter.github.io/finagle/guide/Clients.html#load-balancing
+
+
+### Scalability Pattern - Caching - Content Delivery Networks (CDN)
+
+
+CDNs are added closer to the client’s location. If the app has static data like images, Javascript, CSS which don’t change very often, they can be cached. Since our example is a content sharing site, static content can be cached in CDNs with a suitable expiry.
+
+
+
+**WHAT:** Use CDNs (content delivery networks) to offload traffic from your site.
+
+**WHEN TO USE:** When speed improvements and scale warrant the additional cost.
+
+**HOW TO USE:** Most CDNs leverage DNS to serve content on your site’s behalf. Thus you may need to make minor DNS changes or additions and move content to be served from new subdomains.
+
+Eg
+media-exp1.licdn.com is a domain used by Linkedin to serve static content
+
+Here a CNAME points the domain to the DNS of the CDN provider
+
+dig media-exp1.licdn.com +short
+
+2-01-2c3e-005c.cdx.cedexis.net.
+
+
+**WHY:** CDNs help offload traffic spikes and are often economical ways to scale parts of a site’s traffic. They also often substantially improve page download times.
+
+**KEY TAKEAWAYS:** CDNs are a fast and simple way to offset the spikiness of traffic as well as traffic growth in general. Make sure you perform a cost-benefit analysis and monitor the CDN usage. If CDNs have a lot of cache misses, then we don’t gain much from CDN and are still serving requests using our compute resources.
+
+
+## Scalability - Microservices
+
+This pattern represents the separation of work by service or function within the application. Microservices are meant to address the issues associated with growth and complexity in the code base and data sets. The intent is to create fault isolation as well as to reduce response times.
+
+Microservices can scale transactions, data sizes, and codebase sizes. They are most effective in scaling the size and complexity of your codebase. They tend to cost a bit more than horizontal scaling because the engineering team needs to rewrite services or, at the very least, disaggregate them from the original monolithic application.
+
+
+
+**WHAT:** Sometimes referred to as scale through services or resources, this rule focuses on scaling by splitting data sets, transactions, and engineering teams along verb (services) or noun (resources) boundaries.
+
+**WHEN TO USE:** Very large data sets where relations between data are not necessary. Large, complex systems where scaling engineering resources requires specialization.
+
+**HOW TO USE:** Split up actions by using verbs, or resources by using nouns, or use a mix. Split both the services and the data along the lines defined by the verb/noun approach.
+
+**WHY:** Allows for efficient scaling of not only transactions but also very large data sets associated with those transactions. It also allows for the efficient scaling of teams.
+
+**KEY TAKEAWAYS:** Microservices allow for efficient scaling of transactions, large data sets, and can help with fault isolation. It helps reduce the communication overhead of teams. The codebase becomes less complex as disjoint features are decoupled and spun as new services thereby letting each service scale independently specific to its requirement.
+
+### Refer
+- https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html
+
+## Scalability - Sharding
+
+This pattern represents the separation of work based on attributes that are looked up to or determined at the time of the transaction. Most often, these are implemented as splits by requestor, customer, or client.
+
+Very often, a lookup service or deterministic algorithm will need to be written for these types of splits.
+
+Sharding aids in scaling transaction growth, scaling instruction sets, and decreasing processing time (the last by limiting the data necessary to perform any transaction). This is more effective at scaling growth in customers or clients. It can aid with disaster recovery efforts, and limit the impact of incidents to only a specific segment of customers.
+
+
+
+Here the auth data is sharded based on user names so that DBs can respond faster as the amount of data DBs have to work on has drastically reduced during queries.
+
+There can be other ways to split
+
+
+
+Here the whole data center is split and replicated and clients are directed to a data center based on their geography. This helps in improving performance as clients are directed to the closest data center and performance increases as we add more data centers. There are some replication and consistency overhead with this approach one needs to be aware of. This also gives fault tolerance by rolling out test features to one site and rollback if there is an impact to that geography
+
+**WHAT:** This is very often a split by some unique aspect of the customer such as customer ID, name, geography, and so on.
+
+**WHEN TO USE:** Very large, similar data sets such as large and rapidly growing customer bases or when the response time for a geographically distributed customer base is important.
+
+**HOW TO USE:** Identify something you know about the customer, such as customer ID, last name, geography, or device, and split or partition both data and services based on that attribute.
+
+**WHY:** Rapid customer growth exceeds other forms of data growth, or you have the need to perform fault isolation between certain customer groups as you scale.
+
+**KEY TAKEAWAYS:** Shards are effective at helping you to scale customer bases but can also be applied to other very large data sets that can’t be pulled apart using the microservices methodology.
+
+### Refer
+- https://learning.oreilly.com/library/view/the-art-of/9780134031408/ch23.html
+
+
+
+## Applications in SRE role
+
+1. SREs in coordination with the network team work on how to map users' traffic to a particular site.
+https://engineering.linkedin.com/blog/2017/05/trafficshift--load-testing-at-scale
+2. SREs work closely with the Dev team to split monoliths to multiple microservices that are easy to run and manage
+3. SREs work on improving Load Balancers' reliability, service discovery, and performance
+4. SREs work closely to split Data into shards and manage data integrity and consistency.
+https://engineering.linkedin.com/espresso/introducing-espresso-linkedins-hot-new-distributed-document-store
+5. SREs work to set up, configure, and improve the CDN cache hit rate.
+