Speaker Archive: 2020

How do we measure network level censorship?

1) Usage Metrics (Tor metrics, jumps in usage)
2) Crowd Sourcing (OONI)
3) External Measurements (IC Lab probes)

• External probing (Augur)
• Global Data (IODA)

Differential Privacy (a rant)

- it doesn't work for all problems, yet it is applied to (or attempted for) many questionably:

Geo-Indistinguishability
Machine Learning (with epsilon up to 329,000!)

Voice controlled Devices attacks & Defences

Goals:

• Attack Commands that are decipherable by machines but not humans
• Stealth--don't want to alert nearby humans that device is triggered

Challenges:

• Diff Impl SR
• On the cloud (can't reverse engineer)

Attack Utility:

• Drive by downloads
• Pay by service
• Enumerate Devices in vicinity
• DoS

Attack:

Defense:

• Beep/buzz
• Filter

• The authors did a an extensive study of android apps using static and dynamic analysis
• Identified several new attacks and vulnerabilities related to data leakage

Signal Private Group System

- not a private messaging system, instead: How do you organize the metadata such that the servers never have access to it?

Currently:

- Signal doesn't have a conception of "groups" per se, instead message is 'coincidentally' sent to individual users (that are part of the group) at the same time.

- Race conditions and noticeable strange behaviour

Problems with possible Solutions?

- Plaintext single source of truth allows server to have access to sensitive data. Not an option

- Metadata, timing information, etc is difficult to hide

Highlights from the relevant paper which was published in the Journal of Marketing Science and outlines how firms can use conversational agents to "nudge" individuals to disclose their private data through conversation when they would otherwise prefer to keep their private data concealed.

From this paper:

"We are now entering an era of hyper-privacy, where over the next 10-15 years, aspects of the dark web will be increasingly adopted to the overall web and this will have dire consequences for the modern marketing machinery that relies on rich, abundant and timely consumer data, resulting in a hyper-private, more adversarial environment" (for firms)

It is pinned to the wall of shame ("Know your enemies") in the CrySP lab

Device Sharing Awareness: How can we enable device sharing awareness of smartphones and user applications

Security Solutions for Sharing
- Guest account
- Access from lock screen
- Screen pinning

Presentation of a DSA framework that consists of a foreground service and a client library. The foreground service is responsible for detecting sharing events and providing a global sharing mode. The client enables user applications to have an implicit authentication module and communicate with the service. In the talk, we showcased a DSA-IA enabled gallery app to explain how our framework works.

Interactive lecturing for CS

How do we do active learning in CS?

ex) Jupyter Notebooks, lightweight teams, think-pair-share, clickers/polling

Many students have experienced classes where active learning was used, but this is far from the norm.

Why not?

Institutional Support

Convincing Faculty

1. time & effort
2. training/mentoring
3. fit with practices
4. time to cover content
5. student perceptions
6. awareness of techniques (easy to fix!)

Example: Jupyter NotebooksAdvantages vs. Disadvantages

• interleave lecture notes/activities/examples vs. time
• student freedom vs. requires computer
• flipped classrooms (ex. 458 blog task)

Differential Privacy under sliding window

Situations exist where analyzing data between two periods of time from a stream of data are preferable. This work shows that you can efficiently (time as well as space wise) perform matrix analysis in the privacy with expiration model.

Evading Firewalls By Exploiting State

How do Censors work?
- Deep packet Inspection: search for patterns in application-layer data, are known to be used by censors to detect circumvention systems and HTTP plaintext keywords, can identify and block access to TLS just by looking at the traffic
- TLS Fingerprinting: Censors can examine plaintext messages in the TLS handshake
Client Hello - use one of the ciphersuites, use the ECC params
Every application (+version) has a unique fingerprint which can lead to wholesale blocking of circumvention application systems with minimal collateral damage. Mimicry is an option, but it's very hard to account for slight variations that will identify your system
- Reconstructing TCP Streams
- The Eavesdropper's Dilema: the eavesdropper wants high fidelity understanding which can both: detect evasion and avoid confusion
Perfect sensitivity is impossible and/or expensive:
The censor may not be able to account for weirdness related to: diverse TCP implementations, presence of other middle boxes, unknown network topology

Evasion is possible if the endpoints are more sensitive than the middlebox
TCB Decynchronization Attacks (2013)
- TCB creation attack no longer worked
- TCB teardown mostly worked
Automatically Detecting Evasion Techniques
SymTCP: uses symbolic execution to explore code paths that lead to TCP state changes at endpoints through:
1. manually annotate accept + drop points
2. "offline phase": determine endpoint constraints
3. "online phase": generate packet sequences to test against middle boxes
Geneva: uses a genetic algorithm to duplicate and/or manipulate TCP packets
triggers -> actions
(eg. SYN, RST, ACK) (eg. duplicate, fragment, tamper)
- trained on simulated censors
Discussion: Is it worth the effort to engage in the cat-and-mouse game?
- It is expensive and time consuming for censors to fix every attack
- Can be deployed server-side
- Doesn't defend against endpoint blocking

Cheaper Private Set Intersection via Differentially Private Leakage paper overview
Allowing differentially private leakage can significantly improve the performance of PSI protocols

Rindal and Rosulek protocol works by first having the parties hash their items into bins. (Fastest malicious-secure PSI protocol prior to this paper)

Memory Safety and Stuff

The seemingly best way of ensuring memory safety is formal verification [1] and latter extensions such as separation logic [3]. The seL4 microkernel being a notable example of a formally verified low-level systems software [2]. However, due to complexity and deployment constraints, it is impractical, if not impossible, for many projects Instead, memory safety is often augmented using various �hardening� techniques that often amount to ad-hoc changes on program structure based on observed attacks. Such approaches are often incomplete and only address specific security properties (e.g., W⊕X policies that prevent code-injection but do not prevent data-only attacks). Because such incomplete defenses do not prove the absence of errors, it is not clear what a specific set of defenses means in terms of exploitability of a program. For instance, W⊕X policies are clearly powerful and prevent a whole class of errors, but they still allow Turing complete exploitation. This brings up three questions: 1) How can we evaluate and compare different hardening schemes? 2) How can we evaluate the exploitability of a (partially) hardened program, and 3) Can we use the defense schemes themselves to aid analysis or even verification efforts?

One interesting intersection of �practicality� and verification is symbolic execution [4]. Instead of trying to reason about the program as a whole, symbolic execution tracks the sate during execution and results in symbolic expression derived from the inputs and the input constraints that lead to the executed path through the program (e.g., accumulated branch conditions). By capturing all possible paths, symbolic execution could, in principle, serve as a verification. However, an exhaustive search might not be possible. A practical utilization of symbolic execution is fuzzing, where the patch-specific input constraints can be used to generate new inputs for the fuzzer. (Symbolic execution can be implemented, for instance, by interpreting IR [5], instrumenting binaries [6], or instrumenting the IR during compilation [7]).

Fuzzing and static analyses can be compared against known vulnerabilities in reproducible and scalable way. Despite the practice of showing efficacy against specific CVEs, this approach does not scale for hardening defenses, where PoC exploits can fail due to trivial defenses or even arbitrary differences in compiler internals. For specific defenses other metrics can be used, e.g., quantifying ROP gadgets, but this can be problematic unless the usefulness of the gadgets is taken into account (which newer approaches try to do). The concept of weird machines [8] offers an interesting theoretical view on exploitation, but whether it can be used for evaluation purposes is an open question.

The combination of defense mechanisms with analyses or verification is not novel. Fault-isolation (such as in-process isolation [9]) is a common technique that can guarantee correctness of verified code within a larger non-verified program. CCured is an example of combining static analysis with run-time checks for type safety in C [10]. Other defenses, such as pointer integrity could potentially allow more powerful points-to analyses and verification of some properties that otherwise would depend on full memory safety. Nonetheless, verification of specific properties does not (necessarily) address the question of exploitability nor does it (necessarily) provide a means to compare different security mechanisms, in particular when those defenses are incomplete or enforce slightly different properties.

Post-Quantum TLS without Handshake Signatures

Implicitly authenticated KEX is not new, both in theory (DH-based: SKEME, MQC and KEM-based: BCGP09, FXXY12) and in practice (RSA key transport in TLS<=1.2, Signal, Noise, Wireguard, OPTLS)
"KEMTLS" handshake:
- KEM for ephemeral key exchange
- KEM for server-to-client authenticated key exchange
- Combine shared secrets
Algorithm Choices
- KEM for ephemeral key exchange (IND-CCA or IND-CPA, want small public key + ciphertext)
- KEM for authenticated key exchange (IND-CCA, want small public key + ciphertext)
- Signature scheme for intermediate CA (Want small public key + signature)
- Signature scheme for root CA (want small signature)
4 scenarios
1. Minimize size when intermediate certificate transmitted
2. Minimize size when intermediate certificate not transmitted (cached)
3. Use solely NTRU assumptions
4. Use solely module LWE/SIS assumptions
Security Subtleties
Implicit authentication:
-Clients first application flow can't be read by anyone other than intended server, but client doesn't know server is live at the time of sending
- Also provides a form of deniable authentication since no signatures are used
Downgrade resilience:
- Choice of cryptographic algorithms not authenticated at the time the client sends its first application flow (MITM can't trick client into using undesirable algorithm)
Certificate Lifecycle Management for KEM public keys
Proof of possession: How does requester prove possession of corresponding secret keys?
- not really addressed in practice, since RSA and DL/ECDL keys can be used for both signing and encryption/KEX
- Can't sign like in a Certificate Signing Request (CSR)
- Could do interactive challenge-response protocol (or just run KEMTLS), but need online verification (RFC 3210 Sect. 5.2.8.3)
- Send cert to requestor encrypted under key in the certificate (RFC 4210 Sect. 5.2.8.2) - but maybe broken by Certificate Transparency?
- Zero-Knowledge proof of knowledge
Revocation: How can certificate owner authorize a revocation request?
- Put a hash of a signature public key in the cert

Hiding the access Pattern is Not Enough: Exploiting Search

MLE attack, easy to adapt against defenses, low cost.

Using both access and search pattern leakage is very effective

Current privacy-preserving SSEs do not hide search patterns

Search pattern leakage allows an adversary to get frequency info

Hiding search patterns or frequency info is hard:
- Make access patterns of different keywords identical (expensive of meaningless).
- Hide implicit leakage with fresh access pattern randomness (we can adapt the attack againt this)
- Hide frequency information with dummies:when?how?(we can also adapt the attack against this)

Overview of the Pancake Paper and questions about how it works, drawing in ideas from both Tangler and Hiding Individuals and communities in a social network

Self-Authenticating Traditional (SAT) Addresses
- How do you learn the correct public key? You trust someone who tells you where you should be connecting

Sattestors:
- responsible for communicating with site owners and validating that a public key is associated with a domain name

Pixel-Signatures
In Proof-of-Stake (PoS) and permissioned blockchains, a committee of verifiers agrees and sign every new block of transactions. These blocks are validated, propagated, and stored by all users in the network. However, posterior corruptions pose a common threat to these designs, because the adversary can corrupt committee verifiers after they certified a block and use their signing keys to certify a different block. Designing efficient and secure digital signatures for use in PoS
blockchains can substantially reduce bandwidth, storage and computing requirements from nodes, thereby enabling more efficient applications.

Pixel, a pairing-based forward-secure multi-signature scheme optimized for use in blockchains, achieves substantial savings in bandwidth, storage requirements, and verification effort. Pixel signatures consist of two group elements, regardless of the number of signers, can be verified using three pairings and one exponentiation, and support non-interactive aggregation of individual signatures into a multi-signature. Pixel signatures are also forward-secure and let signers evolve their keys over time, such that new keys cannot be used to sign on old blocks, protecting against posterior corruptions attacks on blockchains.

A Note on the Instantiability of the Quantum Random Oracle
Random Oracle Model (ROM)
All queries to hash functions are managed in a special way in the proof in order to:
- Extract additional information from adversary
- Program certain points
- Guarantee information is unknown to adversary
Quantum Random Oracle Model (QROM)
Adversary with a quantum computer can run hash function in super position
New methods to manage oracle and establish proofs needed

Generally, there exist schemes secure in the QROM that are insecure in the real world, no matter what hash function you use.
The talk discussed how these separations are shown in general, as well as how this (from the fist related paper) specific one works and what the takeaway from such a result should be.