"Hack Yourself First" is all about building up defensive skills in developers. It looks at security from the attacker's perspective and takes them through the steps necessary to exploit vulnerable software on the web so that they can experience hacking first hand. Workshop participants are set specific goals they must complete that involve probing for risks and then exploiting discrete vulnerabilities in a specially built vulnerable application. The interactive nature of the workshop means that multiple attack vectors are usually identified across the spectrum of participants and each person contributes their own unique perspective as to how specific risks are exploited.

The objective of the workshop is that each person walks away with demonstrated experience across a broad spectrum of specific risks. They not only learn about but also demonstrate practical experience across a range of different vulnerabilities targeted to the specific needs of the group.

Courses run for two days on the following schedule:

The first day build fundamental security skills that all technology professionals delivering applications on the web should posses:

- Discovering Risks via the Browser
- Using an HTTP proxy
- XSS
- SQL Injection
- CSRF
- HTTPS
- Framework Disclosure

The second day delves deeper into online risks, covering more advanced topics in greater depth:

- Password Cracking
- Account Enumeration
- FiddlerScript
- Content Security Policy
- Session Hijacking
- Subresource integrity
- Brute Force Attacks
- Automating Attacks and Review

Attendees will get taught the mechanics of each of these risks and of course the defensive patterns required to defend against them. But more than that, they get exposed to how to think about security; how to apply it in depth via multiple defences, how to choose appropriate controls based on the specific risk of the feature and how to have the discussion about what makes sense in different circumstances.

Above all though, security is just one factor in delivering working software and it has to be applied appropriately. Sometimes it comes with a trade-off against usability or cost and decisions have to be made about not what's just most secure, but what's in the overall best interests of the product being built. This workshop helps those who attend have the right discussions about when and where to invest in security.

- Software Developers
- System Administrators
- Testers

This workshop is aimed at any software developer, system admin or tester who wants to get a better understanding what is going on in cyber space if it comes to hacking and cracking of systems. This workshop enables you to take a pro-active approach and you learn how hackers will try to break your system. This workshop will be an eye opener for most attendees and it is the starting point of becoming a better developer. It all starts with awareness and improving your own habits. So start hacking yourself first, to become a better developer!

Attendees will need to use their own computer with one of following software options installed: Fiddler: 

https://portswigger.net/burp/communitydownload

If possible please also bring your smartphone.

2 Days

Hack Yourself First: How to go on the Cyber-Offence

Security

The class is a combination of lectures, security testing demonstrations, code review, and interactive threat modeling discussions. Students will learn the most common threats against applications. More importantly, students will learn how to code secure software via a variety of techniques such as secure design practices, defense-based coding, the use of security libraries and services, and the use of a variety of web security standards.

As part of this course, we will explore the use of third-party security libraries and frameworks to speed and standardize secure development. We will highlight production quality and scalable controls from various languages and frameworks including Java, PHP, Python, Javascript, and .NET, but any developer building web applications and webservices will benefit from this class.

Familiarity with the technical details of building web applications and webservices from a software engineering point of view.

Any laptop that can run an updated web browser and "Burp Community Edition".

Day 1 of the course will focus on web application basics.

Introduction to Security Goals and Threats

Day 2 of the course will focus on API secure coding, Identity, and other advanced topics.

Webservice, Microservice, and REST Security

The course will include several hacking and secure coding labs!

Building Secure API's and Web Applications

2022 is an excellent year to either start learning OAuth & OpenID Connect from scratch or give them a refresher. With the upcoming OAuth 2.1 protocol revision, the protocol has been streamlined and simplified and the specification has been updated to meet modern application and security requirements. At the same time ASP.NET and .NET in general has excellent support for all the moving parts needed to implement an OAuth-based security system.

This full-day workshop teaches you all the OAuth you need utilizing the most common and practical techniques and libraries in the .NET ecosystem. Besides looking at built-in features of (ASP).NET, we will use popular frameworks like IdentityModel and IdentityServer, and we will learn how to use them to secure native/desktop and web applications as well as SPAs, Blazor WASM applications, APIs and daemons.

Typical protocol flows and application scenarios

Simplifying protocol interactions with IdentityModel

JWT Bearer authentication handler for ASP.NET

Automatic token management with IdentityModel.AspNetCore

Integrating various applications into one coherent architecture

Native/desktop applications (e.g. Windows desktop or mobile apps)

1 Day

OAuth, OpenID Connect & .NET – the Good Parts

In this workshop, you will discover best practices for building secure APIs. We investigate various techniques to implement authentication and authorization, along with their trade-offs and pitfalls. We dive deep into handling JSON Web Tokens, but also discuss the relevance of browser security features such as Cross-Origin Resource Sharing. Additionally, we discuss current best practices for securing an API with OAuth 2.0.
This course offers practical and immediately applicable security advice for architects and developers. Throughout the course, Philippe is available to answer any questions, including concrete scenarios applying to your own applications.
Concretely, we will cover the following topics:

Modern security header configurations for APIs

Understanding Cross-Origin Resource Sharing (CORS)

Making authorization decisions with access tokens


This workshop consists of a mixture of lectures, demos, interactive quizzes, and hands-on labs. The lectures provide in-depth knowledge of attacks and defenses. The hands-on labs are conducted in a custom-built competitive training environment, allowing participants to gain hands-on experience with offensive and defensive technologies.

This security training specifically targets API developers. Anyone involved in building API-based systems or managing development teams should be here. This training course is not just any training course. It is packed with in-depth and up-to-date content. We do not merely brush over a threat and defense but focus on the underlying cause and consequences. Why do we have this problem? Which mitigations are often used? Why are some ineffective? Which one is the current best practice? These are the questions that will be answered throughout the training.

To participate in this training, you should have development experience with APIs. Familiarity with the basics of security is helpful, but not required. The training will use examples from the Spring Boot and NodeJS ecosystems, but also applies to other environments.

To participate in the lab sessions, participants need an internet-accessible laptop with a modern browser installed (E.g., Chrome, Firefox).

API security for developers

These environments need more security features than originally specified in OAuth. That’s the reason both the IETF (BCPs) and the OpenID Foundation (FAPI) started working on a number of documents which update the original specs and threat models and give more prescriptive guidance. The discussion during creation of those documents led to the conclusion that OAuth itself needs updates to provide a better security baseline for the things to come.


First, we look at the so-called “best current practices” (or BCP) documents that cover security patterns and anti-patters as well as common attacks and implementation flaws and how to fix them. This includes general implementation guidance, as well as very specific guidance for web applications, SPAs and native apps.

All these BCPs combined form the foundation for the upcoming revision to OAuth called OAuth 2.1



Next, we will look at currently released add-on specifications that help improve the security of today’s OAuth architectures. These include:

hardening the front-channel with PKCE and signed authorization requests

hardening the back-channel with asymmetric key based client authentication and mutual TLS

hardening API calls with proof-of-possession access tokens


In part three we look at future specs that take OAuth to the next level and are in line with the grand vision currently code-named “OAuth 3.0”. This includes:

A replacement for the scope parameter using rich authorization request

Eliminating all classes of attacks against the browser front-channel using pushed authorization requests


In the last part of the workshop, we will have a look at FAPI 2.0 which defines a basic and advanced high-security profile for OAuth 2.0 and 2.1 (independent of financial scenarios) and how to apply it to the technologies you learned throughout the day.

High Security OAuth

.NET

Root, UID transitions, and capabilities (*)

Creating a child process in a new namespace: clone()

Combining user namespaces with other namespaces

What does it mean to be superuser in a namespace?

The BPF virtual machine and BPF instructions

The primary audience comprises designers and programmers building privileged applications, container applications, and sandboxing applications. Systems administrators and DevOps engineers who are managing such applications are also likely to find the workshop of benefit.

The workshop consists of a mixture of presentations coupled with practical exercises that allow participants to apply the knowledge learned in the presentations.

Participants should be familiar with fundamental system programming topics such as file I/O using system calls, signals, and the system calls that define the lifecycle of a process (

). For a refresher on these topics, you can download the course materials available at 

. In addition, participants should have a reading knowledge of the C programming language. (Note, however, that the practical sessions do not require writing C programs.)

You'll need a laptop with Linux installed - either as a native install or inside a virtual machine (VM). You should ensure that you have a fairly recent Linux distribution.

NDC { Security }

Workshops

09:00 - 17:00 (UTC+02)

API security for developers

Philippe De Ryck

OAuth, OpenID Connect & .NET – the Good Parts

Dominick Baier

Hack Yourself First: How to go on the Cyber-Offence

Scott Helme

Building Secure API's and Web Applications

Jim Manico

Linux Security and Isolation APIs Fundamentals

Michael Kerrisk