#dokydoky

Profile

dokydoky — Wed, 2 May 2018 16:24:31 +0900

Facebook

Twitter

HTTPS - 3. SSL/TLS History and Security

dokydoky — Wed, 2 May 2018 14:29:21 +0900

그림으로 살펴보는 포스팅을 시작으로, 3편의 포스팅을 통해 HTTPS에 대해서 알아보겠습니다.
이전 포스팅을 읽어보시지 않으셨다면, 읽어보시는 것을 추천드립니다!
HTTPS - 1. 그림으로 살펴보는 HTTPS
HTTPS - 2. HTTPS의 Ciphersuite, Handshake, Key derivation
HTTPS - 3. SSL/TLS History and Security

들어가며

이번 글에서는 SSL 2.0 ~ TLS 1.3까지의 변화를 간략하게 살펴봅시다!

History & Security

SSL 규약은 처음에 Netscape가 개발하여 2.0버전부터 공식 릴리즈되었습니다. 이후 SSL 2.0의 보안문제들을 개선한 SSL 3.0가 릴리즈되고, TLS 3.0을 기반으로 TLS 1.0이 개발되었습니다.

현재는 TLS 1.2가 가장 많이 사용되고 있으며, 이는 2008년 8월에 표준으로 정의된 것으로 10년정도 되었습니다.

TLS 1.3 규약은 2018년 3월 21일에 무려 28번의 draft를 거치고 최종 확정되었으며, Cloudflare를 비롯해 몇몇 벤더에서는 이미 사용중입니다.

자, 이제 SSL/TLS 각 버전에서 어떤 문제점들이 있었고 어떻게 개선되었는지 알아봅시다.

(위키피디아의 내용을 많이 참조하였습니다.)

SSL 2.0

SSL 2.0은 1995년 2월에 릴리즈되었으며, 2011년 RFC 6176에서 금지되었습니다.

SSL 2.0에서는 여러 문제점들이 있었습니다.

메시지 인증에서 사용되는 key과 암호화에 사용되는 key가 동일했습니다.
→ shared secret에서 각 key를 유도(derivation)해서 사용해야 합니다.
메시지 인증에 사용되는 MAC이 "MD5(secret prefix + data)" 형태로 생성되어, length extension attack에 취약했습니다.
handshake시에 방어책이 없어, 중간자에 의한 downgrade attack을 탐지하지 못했습니다.(SSL 3.0에서 explicit closure alert를 이용해 방지)
TCP 연결 close를 이용해 데이터의 끝을 나타냈기 때문에, 공격자가 TCP FIN을 보냄으로써 truncation attack이 가능했습니다.

SSL 3.0

SSL 3.0은 1996년에 릴리즈되었으며, 2015년 6월에 RFC 7568에서 금지되었습니다.

개선된 점
- SHA-1 기반 암호화를 추가하고 인증서 인증을 지원합니다.
문제 점
- 안전하지 않은 key 유도 과정. master key의 반쪽은 MD5 해쉬함수에 의존하여, 해쉬 충돌(collision)에 안전하지 않습니다.
- 2014년 발표된 POODLE Attack, RC4
  - SSL 3.0의 Block 암호화 방식의 디자인 결함(Encrypt-and-MAC, padding 무결성 미검증)으로 padding attack에 취약(POODLE attack).
  - RC4

TLS 1.0

TLS 1.0은 SSL 3.0의 업그레이드 버전으로, 1999년 1월 RFC 2246에 정의되었습니다.
PCI Council에서는 2018년 6월 30일 이전에 TLS 1.0에서 TLS 1.1이상의 버전으로 업그레이드 할 것을 제안했습니다.
(PCI DSS 영향을 받는 서비스들은 2018.06.30 이전까지 TLS 1.1 이상(권장 TLS 1.2)의 버전으로 업그레이드 해야 합니다.)

개선된 점
- 시퀀스 번호를 사용해 어플리케이션 레코드들을 넘버링하고, 이 시퀀스 번호를 MAC(메시지 인증코드)에서 사용.
- 메시지 인증에 HMAC을 사용.(SSL 3.0에서는 다른 해쉬기반의 MAC을 사용했음) → Length extension attack에 안전.
문제점
- TLS 1.0은 SSL 3.0으로 다운 그레이드 할 수 있는 방법이 있었기에, 보안성을 약화시킬 수 있었음

TLS 1.1

TLS 1.1은 2006년 4월 RFC 4346에 정의되었습니다.

큰 차이점들을 보면,

CBC 모드 공격에 대한 방어를 추가
- implicit IV를 explicit IV로 변경(BEAST Attack 방어)
- 패딩 에러를 처리하는 방법을 변경
매개변수들의 IANA 등록 지원

TLS 1.2

TLS 1.2는 2008년 8월 RFC 5246에 정의되었습니다.

큰 차이점들은 봅시다.

key를 유도할 때 사용되는 PRF(Pseudo Random Function)함수가 TLS 1.1에서는 MD5와 SHA-1 모두 사용(MD5-SHA-1)했지만, TLS 1.2에서는 SHA-256만을 사용.(옵션으로 SHA-256 보다 강한 방식도 선택 가능). TLS 1.1 PRF는 이쪽, TLS 1.2 PRF는 이쪽에서 자세하게 확인 가능.
Finish 메시지에서도 hash값을 생성할 때 MD5-SHA-1 방식에서 SHA-256 방식으로 변경.(사이즈는 여전히 96bits)
Authenticated encryption cipher 지원. 주로 AES GCM, CCM mode가 많이 사용됨.

2011년 3월, RFC 6176에서 모든 TLS 버전은 SSL과의 호환성을 제거하도록 재정의 됨.

TLS 1.2 vs 1.3

TLS 1.3의 큰 특징 두 가지는 "강화된 보안"과 "향상된 속도"입니다.

강화된 보안

TLS 1.3에서는 안전하지 않은 암호화 방식들을 과감하게 지원하지 않습니다.

RSA key transport — Doesn’t provide forward secrecy
CBC mode ciphers — Responsible for BEAST, and Lucky 13
RC4 stream cipher — Not secure for use in HTTPS
SHA-1 hash function — Deprecated in favor of SHA-2
Arbitrary Diffie-Hellman groups — CVE-2016-0701
Export ciphers — Responsible for FREAK and LogJa

이외에도, Perfect Forward Secrecy를 지원하는 키 교환방식만을 허용하거나 AEAD 암호화만 허용하는 등의 개선도 있습니다.
이쪽에서 추가적으로 더 확인하실 수 있습니다.

향상된 속도

Handshake 과정이 2-RTT에서 1-RTT로 변경되어 지연(latency)가 줄어들었습니다.

추가적으로, TLS 1.3에서는 이전에 handshake했던 두 대의 컴퓨터가 서로의 정보를 저장한 뒤,
향후 연결에 이전 키를 사용하는 것을 허용하는 0-RTT Resumption을 지원합니다.

출처 : https://en.wikipedia.org/wiki/Cipher_suite#TLS_1.0%E2%80%931.2_handshake

마치며

SSL/TLS 버전별 개선점에 대한 내용을 마지막으로 이번 시리즈를 마칩니다!

읽어주셔서 감사합니다.

Reference

Wikipedia : Transport Layer Security
https://en.wikipedia.org/wiki/Transport_Layer_Security
Introducing TLS 1.3
https://blog.cloudflare.com/introducing-tls-1-3/
Cipher suite
https://en.wikipedia.org/wiki/Cipher_suite#TLS_1.0%E2%80%931.2_handshake

HTTPS - 2. HTTPS의 Ciphersuite, Handshake, Key derivation

dokydoky — Sun, 15 Apr 2018 22:12:03 +0900

그림으로 살펴보는 포스팅을 시작으로, 3편의 포스팅을 통해 HTTPS에 대해서 알아보겠습니다.

이전 포스팅을 읽어보시지 않으셨다면, 읽어보시는 것을 추천드립니다!

들어가며

1편에서는 HTTPS의 동작방식을 그림으로 간단하게 살펴봤습니다.

전편에서는 RSA 기반의 키교환 중심으로 설명했지만, ECDHE와 같이 Diffie-hellman 기반의 알고리즘도 많이 사용됩니다.

이번편에서는 TLS에서 사용되는 Cipher suites, Handshake를 알아보며 Perfect Forward Secrecy, ECC에 대해서도 알아봅시다.

그리고 키교환을 통해 얻은 pre-master secret은 4가지의 key로 유도(Derive)되는 것을 알고 계셨나요?

어떤 key들이 필요하고 어떻게 유도하는지에 대해서도 자세히 알아봅시다.

Cipher suites

HTTPS에서 사용되는 Cipher suite는 크게 2가지 부분으로 나눠 볼 수 있습니다.

안전한 키 교환을 위한 키교환 방법(Key establishment)와 인증서 검증 방법(Authentication).
메시지 암호화를 위한 암호화 알고리즘(Cipher)과 메시지의 무결성을 검증하기 위한 Data integrity.

자 그럼 하나씩 살펴봅시다.

Key establishment

키교환은 크게 RSA기반과 Diffie hellman(DH)기반 방법이 있으며, DHE, ECDH, ECDHE는 DH(Diffie-Hellman)의 변형입니다.

RSA, DH 키교환과 Forward secrecy, ECC에 대해 알아봅시다.

RSA key exchange

Alice가 symmetric key를 생성 후 Bob의 RSA public key로 암호화하여 Bob에게 전송합니다.

Diffie-Hellman Key exchange

RSA와는 달리, Alice와 Bob이 각자 생성 후 교환한 파라미터를 이용해 shared secret를 만듭니다.

Alice가 secret값 a를 갖고, g^a 값을 Bob에게 전송.
Bob은 secret값 b를 갖고, g^b 값을 Alice에게 전송.
Alice 키 계산. shared secret = (g^b)^a = g^(ab)
Bob 키 계산. shared secret = (g^a)^b = g^(ab)

Alice와 Bob은 shared secret을 공유했지만, 엿듣고 있는 Mallory는 g^a, g^b값으로 동일한 값을 만들어 내지 못합니다.

참고) 실제로는 수학적 해결이 힘들도록, 큰 소수로 modular 연산을 한 결과를 사용합니다.

PFS(Perfect Forward secrecy)란?

PFS는 서버의 private key가 누출되더라도, 해당 key쌍을 사용했던 과거의 TLS session들이 보호되는 특성입니다.

위 그릠에서와 같이 RSA 키교환 방식에서는 Mallory가 Alice와 Bob간의 암호화된 메시지를 기록해놓은 상황에서,

Bob의 private key가 누출될 경우 과거의 암호화된 메시지를 복호화할 수 있게 됩니다.

ECC(Elliptic curves cryptography)란?

타원곡선(elliptic-curve)의 수학적 특성을 이용하는 암호화 알고리즘으로써, non-elliptic curve 알고리즘에 비해 key 사이즈가 현저하게 작습니다.

따라서 동일한 보안성을 제공할 때, 다른 알고리즘에 비해 작은 key를 사용하여 더 빠른 속도를 제공해줍니다.

Symmetric Key Length	Standard asymmetric Key Length	Elliptic Curve Key Length
80	1024	160
112	2048	224
128	3072	256
192	7680	384
256	15360	512

https://wiki.openssl.org/index.php/Elliptic_Curve_Cryptography

(Certificate) Authentication

CA에 의해 서명된 Certificate의 signature를 확인할 때 사용되는 알고리즘으로, RSA나 ECC 기반의 ECDSA가 많이 사용됩니다.

Key establishment와 Authentication 조합으로 인증된 키 교환(Authenticated Key exchange)을 제공합니다.

Cipher

키교환을 완료 한 뒤, 메시지 암호화에 사용되는 symmetric 암호화 알고리즘입니다.

AES_256_GCM 의 경우. 암호화 알고리즘은 AES, key size는 256bit, mode는 GCM를 사용한다는 뜻입니다.

https://en.wikipedia.org/wiki/Transport_Layer_Security#Cipher

Data Integrity

데이터 암호화는 기밀성을 제공해주지만, 무결성을 제공해주지 않기 때문에 별도의 무결성 검증 방식을 사용합니다.

HMAC으로 인증값을 생성하거나, 애초 암호화할 때 인증값을 포함한 Authenticated Encryption(ex.CCM, GCM)을 사용할 수 있습니다.

HMAC값을 생성할 때 필요한 key는 pre-master key에서 유도(derive)해서 사용합니다.
(유도 과정은 이 글의 마지막에서 자세히 다루겠습니다.)

https://en.wikipedia.org/wiki/Transport_Layer_Security#Data_integrity

TLS 1.3부터는 AEAD(Authenticated Encryption with Associated Data)만을 지원하는데, AEAD는 GCM와 CCM 모드와 같이

암호화 과정에서 인증값도 함께 추가하는 방식입니다. 암호화와 메시지 인증을 함께 합쳐놓은 인증된 암호화(Authentication Encryption) 방식입니다.

Handshake

2가지 키교환 방식(RSA, Ephermeral Diffie-Hellman)에 대해 handshake 과정을 살펴보겠습니다.

특히, Ephermeral Diffie-Hellman 키교환은 PFS(Perfect Forward Secrecy)를 지원하는 방식입니다!

이 내용은 CloudFlare 블로그 글 중 Keyless SSL: The Nitty Gritty Technical Details에 설명이 잘 되어 있습니다.

특히 그림을 너무 잘 그려주셔서, 이 그림을 가져와서 간단히 짚고 가보겠습니다. 더 상세한 내용은 원문도 확인해보세요!

RSA handshake

(a nice figure, thanks CloudFlare!) https://blog.cloudflare.com/content/images/2014/Sep/ssl_handshake_rsa.jpg

"Client Hello"
client random와 클라이언트가 지원하는 protocol version, client cipher suite 리스트, SNI extension(옵션), curve 리스트(ECDHE의 경우) 전송합니다.
"Server Hello"
서버는 client hello를 받고 protocol version, cipher suite, curve를 결정합니다. 그리고 클라이언트에게 server random, cipher suite, server의 certificate를 전송합니다.
"Client Key Exchange"
Client는 certificate을 검증한 후에, pre-master secret을 만들고 certificate에 포함된 public key로 암호화하여 서버에서 전송합니다.

서버는 암호화된 pre-master secret을 자신의 private key로 복호화함으로써 client와 server는 pre-master secret을 공유했습니다.
이후에는 pre-master secret과 client random, server random을 이용해 session key를 유도한 뒤, session key를 이용해 암호화된 데이터 통신을 합니다.

Ephermeral Diffie-Hellman handshake

(a nice figure, thanks CloudFlare!) https://blog.cloudflare.com/content/images/2014/Sep/ssl_handshake_diffie_hellman.jpg

"Client Hello"
RSA의 경우와 동일하게, client random, 클라이언트가 지원하는 protocol version, client cipher suite 리스트, SNI extension(옵션), curve 리스트(ECDHE의 경우) 전송합니다.
"Server Hello"
서버는 client hello를 받고 protocol version, cipher suite, curve를 결정합니다. 그리고 클라이언트에게 server random, cipher suite, server의 certificate를 전송합니다.
"Server Key Exchange"
diffie-hellman 키교환을 위해 서버는 DH parameter를 생성합니다. 그리고 DH parameter의 인증(authentication)을 위해 자신의 private key로 signature를 생성 후 함께 보냅니다.
"Client Key Exchange"
클라이언트는 certificate와 DH parameter의 signature를 검증 한 뒤, 클라이언트의 DH parameter를 보냅니다.

이후 클라이언트와 서버는 각각 주고받은 DH parameter를 이용해 premaster secret을 유도한 뒤,
premaster secret과 client random, server random을 조합하여 session key를 유도합니다.

Ephermeral Diffie-Hell의 경우에는 session마다 새로운 random key가 생성되며, DH의 특성상 중간자는 premaster secret을 유추할 수 없게 되므로 PFS가 보장됩니다.

Key Derivation

앞에서 잠시 언급했지만, 키교환 과정을 통해 얻은 Pre-master secret을 바로 암호화 키로 사용하지 않습니다.

어떤 키들을, 어떻게 유도하는지 확인해봅시다!

우선, Pre-master secret은 키교환에 사용한 알고리즘에 따라 길이가 다르므로, 48bit의 master secret으로 변환합니다.

코드는 RFC에서 참조했습니다.
(PRF 함수에 대해서는 밑에서 자세히 다룹니다. 지금은 특정입력값을 seed값으로 안전한 랜덤 바이트열을 출력하는 함수로 이해합시다.)

master_secret = PRF(pre_master_secret, "master secret",
                  ClientHello.random + ServerHello.random)
                  [0..47];

이제 이 master secret을 확장시킨 후, 순서대로 4개 key를 유도합니다.
"client/server write IV"는 AEAD cipher를 사용할 때만 추가적으로 필요한 것으로, AEAD cipher를 사용할 경우 4개의 key와 더불어 함께 유도(derive)합니다.

a client write MAC key
a server write MAC key
a client write encryption key
a server write encryption key
(a client write IV)
(a server write IV)

코드는 RFC에서 참조했습니다.

// master secret을 entorpy source로 key material을 계산
key_block = PRF(SecurityParameters.master_secret,
                "key expansion",
                SecurityParameters.server_random +
                SecurityParameters.client_random);
 
// 충분한 길이가 될 때까지 반복하여 생성한 뒤, 순서대로 아래 key들로 사용.
client_write_MAC_key[SecurityParameters.mac_key_length]
server_write_MAC_key[SecurityParameters.mac_key_length]
client_write_key[SecurityParameters.enc_key_length]
server_write_key[SecurityParameters.enc_key_length]
client_write_IV[SecurityParameters.fixed_iv_length]
server_write_IV[SecurityParameters.fixed_iv_length]

PRF(PseudoRandom Function)

PRF는은 secret, seed, identifying label을 입력받아 임의 길이의 출력을 만드는 함수입니다.

TLS 1.2에서 사용되는 PRF는 이쪽, TLS 1.1에서 사용되는 PRF는 이쪽에서 확인할 수 있으며, 구현이 꽤 다릅니다.
재밌는 것은 TLS 1.2에 사용되는 PRF가 더 간단하다는 겁니다.

여기서는 TLS 1.2 기준으로 PRF를 알아보겠습니다.

PRF는 아래와 같이 정의되며, hash함수는 SHA-256 혹은 더 강한 해쉬 알고리즘을 사용해야 합니다.

PRF(secret, label, seed) = P_<hash>(secret, label + seed)

P_hash함수는 데이터 길이를 늘려주는 함수로 내부적으로 HMAC을 사용합니다.

P_hash(secret, seed) =  HMAC_hash(secret, A(1) + seed) +
                        HMAC_hash(secret, A(2) + seed) +
                        HMAC_hash(secret, A(3) + seed) + ...
 
 
where + indicates concatenation.
 
 
A() is defined as:
  A(0) = seed
  A(i) = HMAC_hash(secret, A(i-1))

예를 들어, 80byte 길이의 데이터를 만들고 싶고 P_SHA256을 이용할 경우,

SHA256기반의 HMAC 함수를 3번 사용해 데이터를 붙이면 32*3=96 byte의 데이터가 되고,
이중 16 byte를 버려서 80 byte의 데이터를 만듭니다.

마치며

이번 편에서는 TLS의 Cipher suites, Handshake, Key derivation에 대해서 알아봤습니다.

다음편에서는 TLS 버전별 차이점들과 몇가지 취약점들에 대해서 알아봅시다.

Reference

Transport Layer Security
https://en.wikipedia.org/wiki/Transport_Layer_Security#Cipher
Elliptic Curve Cryptography
https://wiki.openssl.org/index.php/Elliptic_Curve_Cryptography
Keyless SSL: The Nitty Gritty Technical Details
https://blog.cloudflare.com/keyless-ssl-the-nitty-gritty-technical-details/
TLS, Pre-Master Secrets and Master Secrets
https://www.cryptologie.net/article/340/tls-pre-master-secrets-and-master-secrets/
RFC5246 - The Transport Layer Security (TLS) Protocol Version 1.2
https://tools.ietf.org/html/rfc5246#section-6.3

HTTPS - 1. 그림으로 살펴보는 HTTPS

dokydoky — Thu, 12 Apr 2018 21:59:39 +0900

그림으로 살펴보는 포스팅을 시작으로, 3편의 포스팅을 통해 HTTPS에 대해서 알아보겠습니다.

들어가며

암호화의 구현이 필요한 시스템이나 프로토콜을 설계할 때 HTTPS(HTTP Over TLS)의 동작방식은 좋은 레퍼런스가 될 수 있습니다.

우선 이번 글에서는 그림을 통해 HTTPS가 어떻게 동작하는지 간단하게 살펴보겠습니다.

평문 전송부터 시작해, 하나씩 필요한 기능들을 추가해보면서 필요한 이유들을 이해해봅시다.

용어정리

대칭암호화(Symmetric Encryption), 비대칭 암호화(Asymmetric Encryption), 서명(Signing)의 개념에 대해서는 간단하게 정리만 하고 가겠습니다.

암호화에 필요한 개념은 이쪽글을 읽어보는 것을 추천드립니다.

Symmetric Encryption :
- 같은 키를 이용해 암/복호화하는 방식
- 보통 데이터 암호화에 사용되며 AES 알고리즘이 많이 사용된다.
Asymmetric Encryption :
- 공개키(Public key), 개인키(Private key) 쌍으로 존재
- 공개키로 암호화하면 개인키로 복호화, 개인키로 암호화하면 공개키로 복호화를 한다.
- 공개키를 가지고 개인키를 알아낼 수 없다(역도 성립).
- 보통 키교환, 서명에 사용된다.
- ex) RSA

Signing
- 우리가 알고 있는 서명과 같은 의미로, 개인키를 이용해 서명하고 공개키를 이용해 확인한다.
- 부인방지, 무결성을 제공한다.
- ex) RSA, ECDSA

Plaintext - HTTP

우선, Alice가 Bob에게 메시지를 평문으로 전송하는 경우입니다.

이렇게 평문으로 메시지를 전송할 경우는 Mallory가 간단하게 Alice의 메시지를 가로챈 후 Bob에게 변조된 메시지를 전송할 수 있습니다.

Symmetric encryption

이번에는 메시지를 보호하기 위해 Symmetric 암호화를 이용해 메시지를 암호화하기로 하였고,

이를 위해 사전에 Alice는 Bob에게 암호화 Key를 전송하기로 했습니다.

하지만, 이 경우에는 key를 교환하는 방식에 문제가 있습니다.

Alice가 key를 전송할 때 Mallory가 이 key를 가로챈 후 Bob에게 새로운 암호화 key를 전송한다면,

Mallory는 Alice, Bob간의 암호화된 메시지를 읽고, 변조할 수 있게 됩니다.

Alice가 Bob에게 Key 전송
Mallory가 Key를 가로챈 후, Bob에게 Fake Key 전송
Alice는 본인이 전송한 Key를 이용해 메시지를 암호화하여 전송
Mallory는 Key를 이용해 Alice의 메시지를 복호화
Mallory는 Fake Key를 이용해 변조된 메시지를 암호화하여 Bob에게 전송.

RSA key exchange

이번에는 Key를 안전하게 교환하기 위해 Asymmetric encryption 기반의 key 교환방식을 추가하였습니다.
과정은 이렇습니다.

Bob은 Asymmetric key 한 쌍(Private Key, Public Key)을 만든 뒤, Alice에게 Public key를 공유.
Alice는 Symmetric key를 생성한 뒤, Public key를 이용해 Key를 암호화하여 Bob에게 전송.
Bob은 암호화된 Key를 private key를 이용해 복호화.
Alice, Bob은 교환된 key를 이용해 메시지를 암/복호화.

참고) 메시지 자체를 Asymmetric encryption을 이용해 암/복호화 하지 않는 이유는 Asymmetric encryption이 Symmetric encryption 방식에 비해 현저히 느리기 때문입니다.
따라서 메시지 암호화는 Symmetric encrpytion을 이용하고, 암호화 key 교환은 Asymmetric encryption 방식을 사용합니다.

하지만, 이 방식에도 문제가 있습니다. Alice는 전송받은 Public key가 Bob의 것인지 확신할 수 없습니다.

Bob이 Alice에게 Public key를 전송할 때 Mallory가 가로챈 뒤, Mallory의 Public key를 보낸다면

Mallory는 다시 Alice와 Bob의 통신을 가로챌 수 있게 됩니다.

Bob은 asymmetric key 한 쌍(Private Key, Public Key)을 만든 뒤, Alice에게 Public key를 공유.
Mallory는 Bob의 Public key를 가로챈 뒤, Alice에게 자신의 Public key를 전송.
Alice는 Key를 생성 후, Mallory의 Public key를 이용해 암호화하여 전송.
Mallory는 본인의 Private key를 이용해 Key를 복호화 한 뒤, Bob에게는 Fake key를 Bob의 Public key로 암호화하여 전송.
Mallory는 Key, Fake key를 이용해 Alice, Bob의 통신 내용을 읽고 변조.

Web PKI

이번에는 Bob의 Public key를 검증하기 위해 Web PKI를 추가로 이용하기로 했습니다.

PKI에서는 Public key를 검증하기 위해, Certificate 포맷을 만들고 제 3자인 CA(Certificate Authority)의 도움을 받습니다.

Public key를 검증하기 위해, Bob, Alice는 키교환과정 이전에 아래의 작업이 필요합니다.

Bob

1. Bob은 Asymmetric Key 한 쌍을 만듭니다.(Public key, Private key)
2. Bob은 위에서 만든 Public key를 포함한 Certificate 포맷을 만든 후, 외부 신뢰기관(CA)에게 서명 요청을 합니다.(CSR)
3. CA는 Bob의 정보를 확인한 뒤, CA의 private key를 이용해 certificate에 서명(signature 추가)을 합니다.
4. Bob은 서명받은 Certificate를 서버에 설치합니다.

Alice

1. Alice는 신뢰할 수 있는 CA들의 public key를 이미 갖고 있습니다.(OS 혹은 browser 내장)

통신을 시작할 때, Bob은 CA에게 미리 서명받은 Certificate를 Alice에게 보냅니다.

Alice는 Certificate를 받은 후, CA의 서명(signature)를 확인하여 Certificate의 내용이 변조되지 않았음을 확인합니다.

(Certificate 내의 Hostname을 보고 통신하고 있는 상대가 Bob이란 것도 확인합니다.)

Alice는 서명을 확인할 때, 이미 갖고 있는 CA의 Public key를 이용합니다.(OS 혹은 Browser등에 설치되어 있음)

마치며

이제까지 HTTPS의 동작방식을 간단하게! 살펴보았습니다.

하지만, 위에서 본 것과는 달리 실제로는 교환한 키를 바로 암호화 키로 사용하지는 않습니다.

교환한 키는 pre-master key라고 부르며, pre-master key에 random값들을 조합하여 master key를 유도(derive)하여 사용합니다.

다음 글에서는 HTTPS에서 사용되는 추가적인 키 교환방식들과 메시지 암호화 알고리즘, 메시지 무결성 검증 방법 등을 포함해 좀 더 자세히 살펴봅시다.

Reference

HTTPS explained with carrier pigeons
https://medium.freecodecamp.org/https-explained-with-carrier-pigeons-7029d2193351

[Heap Exploitation] Smallbin attack

dokydoky — Wed, 9 Aug 2017 15:54:56 +0900

Reference

smallbin

About smallbin

총 62개의 small bin
free될 때 앞,뒤 chunk가 free되었다면 병합(coalesce)
삽입은 HEAD, 제거는 TAIL (FIFO)

32bit

size : 0x10, 0x18, 0x20 ...... , 0x1F8(504)
(8x+8, 1<=x<=62)

64bit

size : 0x20, 0x30, 0x30 ...... , 0x3F0(1008)
(16x+16, 1<=x<=62)

The code of getting chunk from smallbins in malloc

malloc - smallbin

if (in_smallbin_range (nb))
  {
    idx = smallbin_index (nb);
    bin = bin_at (av, idx);
 
    if ((victim = last (bin)) != bin)
      {
        if (victim == 0) /* initialization check */
          malloc_consolidate (av);
        else
          {
            bck = victim->bk;
  if (__glibc_unlikely (bck->fd != victim))
              {
                errstr = "malloc(): smallbin double linked list corrupted";
                goto errout;
              }
            set_inuse_bit_at_offset (victim, nb);
            bin->bk = bck;
            bck->fd = bin;
 
            if (av != &main_arena)
              victim->size |= NON_MAIN_ARENA;
            check_malloced_chunk (av, victim, nb);
            void *p = chunk2mem (victim);
            alloc_perturb (p, bytes);
            return p;
          }
      }
  }

Attacks

House of Lore

공격개요

free된 후 smallbin에 들어간 chunk의 bk를 조작하여, 임의의 chunk를 smallbin에 넣는 공격

제약조건

smallbin size의 chunk는 free된 후 unsorted bin에 들어가므로, 더 큰 크기를 할당하여 chunk를 unsorted bin→small bin으로 이동시켜야 한다.
아래와 같은 체크로직을 우회하기 위해 아래 조건을 만족해야 한다.
- real_chunk→bk = fake_chunk
- fake_chunk→fd = real_chunk
- fake_chunk→bk = another_chunk
- another_chunk→fd = fake_chunk

malloc - smallbin check

          bck = victim->bk;
if (__glibc_unlikely (bck->fd != victim))
            {
              errstr = "malloc(): smallbin double linked list corrupted";
              goto errout;
            }
          set_inuse_bit_at_offset (victim, nb);
          bin->bk = bck;
          bck->fd = bin;

[Heap Exploitation] Fastbin attack

dokydoky — Wed, 9 Aug 2017 15:54:19 +0900

Reference

Double free
- https://heap-exploitation.dhavalkapil.com/attacks/double_free.html
- https://github.com/shellphish/how2heap/blob/master/fastbin_dup.c
Forging chunks
- https://heap-exploitation.dhavalkapil.com/attacks/forging_chunks.html
- https://github.com/shellphish/how2heap/blob/master/fastbin_dup_into_stack.c (double free + forging chunks)
House of spirit
- https://heap-exploitation.dhavalkapil.com/attacks/house_of_spirit.html
- https://github.com/shellphish/how2heap/blob/master/house_of_spirit.c

Overview

Fastbin

arena(malloc_state)

gdb-peda$ p main_arena
$1 = {
  mutex = 0x0,
  flags = 0x0,
  fastbinsY = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},  // mfastbinptr fastbinsY[NFASTBINS]; // NFASTBINS = 10
                                                                   // fastbin은 arena별로 10가지 크기의 list 존재 -> 하지만 실제로 7개만 사용하는 듯.
  top = 0x0,
  last_remainder = 0x0,
  bins = {0x0 <repeats 254 times>},
  binmap = {0x0, 0x0, 0x0, 0x0},
  next = 0x7ffff7dd1b20 <main_arena>,
  next_free = 0x0,
  attached_threads = 0x1,
  system_mem = 0x0,
  max_system_mem = 0x0
}

32bit machine

min size(metadata 포함) : 0x10 (header: 0x8, data: 0x8)
max size : 0x40 (header: 0x8, data = 0x38)
alignment size : 0x8

32bit fastbin

gdb-peda$ heapinfo
(0x10)     fastbin[0]: 0x0
(0x18)     fastbin[1]: 0x0
(0x20)     fastbin[2]: 0x0
(0x28)     fastbin[3]: 0x0
(0x30)     fastbin[4]: 0x0
(0x38)     fastbin[5]: 0x0
(0x40)     fastbin[6]: 0x0

64bit machine

min size : 0x20 (header: 0x10, data: 0x10)
max size : 0x80 (header: 0x10, data: 0x70)
alignment size : 0x10

64bit fastbin

gdb-peda$ heapinfo
(0x20)     fastbin[0]: 0x0
(0x30)     fastbin[1]: 0x0
(0x40)     fastbin[2]: 0x0
(0x50)     fastbin[3]: 0x0
(0x60)     fastbin[4]: 0x0
(0x70)     fastbin[5]: 0x0
(0x80)     fastbin[6]: 0x0

Attacks

Double Free

공격개요

fastbin size의 chunk를 double free하여, malloc을 여러번 호출했을 때 동일한 주소를 2번 반환 받을 수 있다.

ex)
free(a) // size=10
free(b)
free(a)
 
 
malloc(10) // a
malloc(10) // b
malloc(10) // a

제약조건

fastbin의 top에 있는 chunk와 free하는 chunk가 같으면, double free corruption.

free - fastbin check

if NOT) minumum <= next chunk's size <= maximum(av->system_mem)
    error ("free(): invalid next size (fast)")
if) the chunk at the top == the chunk we are going to add
    error ("double free or corruption (fasttop)")
if NOT) the size of the chunk at the top == the size of the chunk we are adding.
    error ("invalid fastbin entry (free)")
Insert the chunk at the top of the fastbin list and return.

Forging chunks

공격개요

fastbin size의 chunk가 free되고 fastbin에 들어간 뒤, 해당 free된 chunk의 fd의 값의 조작이 가능하다면 malloc의 결과로 원하는 주소를 리턴받을 수 있다.

(fastbin뿐만 아니라, 다른 binlist에도 적용되는 내용.)

제약조건

단, malloc 함수내에서 아래와 같이, 요청한 크기와 fastbin에서 꺼낸 chunk의 크기가 같은 것을 확인하므로, fakechunk.size를 chunk.size와 동일하게 설정해줘야 한다.

malloc - fastchunk size check

3383           if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))                 
3384             {
3385               errstr = "malloc(): memory corruption (fast)";                                   
3386             errout:
3387               malloc_printerr (check_action, errstr, chunk2mem (victim), av);                  
3388               return NULL;
3389             }

House of spirit

공격개요

free되기 전에 free되는포인터(ptr)를 조작하여 binlist에 fake chunk을 넣을 수 있는 방법.
다른 binlist들도 가능하나, fastbin이 선호됨.

제약조건

fakechunk.size : fastbin range (fastbin을 이용할 경우)
fakechunk's next chunk's size : >2*SIZE_SZ AND < av→system_mem(128kb by default for the main arena)

free pseudo-code

if NOT) p is before p+chunksize(p)
    error ("free(): invalid pointer")
  
if NOT) chunk >= MINSIZE OR multiple of MALLOC_ALIGNMENT // chunk.size를 해당 범위로 설정해줘야 함
    error ("free(): invalid size")
   
if) chunk's size == fastbin range // chunk.size를 fastbin 크기로 설정해줘야 이 구문이 실행
    if NOT) minumum <= next chunk's size <= maximum(av->system_mem) // nextchunk.size를 해당 범위로 설정
        error ("free(): invalid next size (fast)")
    if) the chunk at the top == the chunk we are going to add
        error ("double free or corruption (fasttop)")
    if NOT) the size of the chunk at the top == the size of the chunk we are adding.
        error ("invalid fastbin entry (free)")
    Insert the chunk at the top of the fastbin list and return.
  
if) chunk is not mmapped
    if) the chunk == top chunk
        error ("double free or corruption (top)")
    if NOT) next chunk is within the boundaries of the arena
        error ("double free or corruption (out)")
    if NOT) next chunk's PREVIOUS_IN_USE bit is marked
        error ("double free or corruption (!prev)")
    if NOT) minumum <= next chunk's size <= maximum(av->system_mem)
        error ("free(): invalid next size (normal)")
   
    if) previous chunk is not in use
        unlink(previous chunk)
    if) next chunk != top chunk
        if) next chunk is not in use
            unlink(next chunk)
        Merge the chunk with previous or next, if free
        if NOT) unsorted_chunks(av)->fd->bk == unsorted_chunks(av)
            error ("free(): corrupted unsorted chunks")
        Add it to the head of unsorted bin
    else) // not top chunk
        Merge the chunk into a single top chunk
   
else)
    call munmap_chunk

[Heap Exploitation] malloc & free(glibc 2.23)

dokydoky — Wed, 9 Aug 2017 15:53:18 +0900

Reference

It is a simple version of dhavalkapil's work
https://heap-exploitation.dhavalkapil.com/diving_into_glibc_heap/core_functions.html

glibc 2.23 code
http://repo.or.cz/glibc.git/commit/ab30899d880f9741a409cbc0d7a28399bdac21bf

Malloc

Malloc pseudo-code

//step 1
if) size == fastbin range
    'return chunk' = chunk at the end of the the fastbin list
    if) return chunk == null
        move on to 'smallbin case'
    else)
        check 'the size of the chunk' == 'requested size'
        ("malloc(): memory corruption (fast)")
if) size == smallbin range
    if) chunk of requested size doesn't exist in smallbin
        call 'malloc_consolidate'
        skip into different bins
    else)
        check victim→bk→fd == victim
        ("malloc(): smallbin double linked list corrupted")
        Sets the PREV_INSUSE bit for the next chunk
if) size != smallbin range
    if) av has fastchunks
        call 'malloc_consolidate'
 
 
//step 2 : check unsorted chunks
victim : one of the chunks in unsorted bin.
while(MAX_ITERS (10000) times OR unsorted bin get exhausted)
{
    if) !(size >= minimum (2*SIZE_SZ) AND size <= maximum (av→system_mem))
        Throw an error ("malloc(): memory corruption")
    if) (size of requested chunk falls in smallbin range) and (victim is the last remainder chunk)
         and (it is the only chunk in the unsorted bin) and (the chunks size >= the one requested)
        split into 2 chunks. one for return, the other for last remainder chunk.
    else)
        Remove the chunk from the unsorted bin.
        Add it to smallbin or largebin depends on the size.
}
 
 
//step 3 : check largebins
split the chunk into two chunks('return chunk' and 'unsorted bin chunk').
if) !( unsorted_chunks(av)->fd->bk == unsorted_chunks(av) )
    ("malloc(): corrupted unsorted chunks")
Otherwise, the entire victim chunk will be returned
 
 
//step 4 : check a single bin(fast or small)
split it into 2 chunks.('return chunk' and 'unsorted bin chunk').
if) !( unsorted_chunks(av)->fd->bk == unsorted_chunks(av) )
    ("malloc(): corrupted unsorted chunks 2")
 
 
//step 5 : top chunk
split it into 2 chunks.('return chunk' and 'top chunk')
if) has fastchunks
    call 'malloc_consolidate'
    return to step of 'check unsorted chunks'
  

Exception codes in Malloc

fastbin check

3381       if (victim != 0)
3382         {                                                                                       
3383           if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))                  
3384             {
3385               errstr = "malloc(): memory corruption (fast)";                                    
3386             errout:
3387               malloc_printerr (check_action, errstr, chunk2mem (victim), av);                   
3388               return NULL;
3389             }
3390           check_remalloced_chunk (av, victim, nb);
3391           void *p = chunk2mem (victim);                                                         
3392           alloc_perturb (p, bytes);
3393           return p;                                
3394         }

smallbin check

3416               bck = victim->bk;
3417         if (__glibc_unlikely (bck->fd != victim))
3418                 {
3419                   errstr = "malloc(): smallbin double linked list corrupted";
3420                   goto errout;
3421                 }
3422               set_inuse_bit_at_offset (victim, nb);
3423               bin->bk = bck;
3424               bck->fd = bin;

Free

Free pseudo-code

if NOT) p is before p+chunksize(p)
    error ("free(): invalid pointer")
 
if NOT) chunk >= MINSIZE OR multiple of MALLOC_ALIGNMENT
    error ("free(): invalid size")
  
if) chunk's size == fastbin range
    if NOT) minumum <= next chunk's size <= maximum(av->system_mem)
        error ("free(): invalid next size (fast)")
    if) the chunk at the top == the chunk we are going to add
        error ("double free or corruption (fasttop)")
    if NOT) the size of the chunk at the top == the size of the chunk we are adding.
        error ("invalid fastbin entry (free)")
    Insert the chunk at the top of the fastbin list and return.
  
if) chunk is not mmapped
    if) the chunk == top chunk
        error ("double free or corruption (top)")
    if NOT) next chunk is within the boundaries of the arena
        error ("double free or corruption (out)")
    if NOT) next chunk's PREVIOUS_IN_USE bit is marked
        error ("double free or corruption (!prev)")
    if NOT) minumum <= next chunk's size <= maximum(av->system_mem)
        error ("free(): invalid next size (normal)")
  
    if) previous chunk is not in use
        unlink(previous chunk)
    if) next chunk != top chunk
        if) next chunk is not in use
            unlink(next chunk)
        Merge the chunk with previous or next, if free
        if NOT) unsorted_chunks(av)->fd->bk == unsorted_chunks(av)
            error ("free(): corrupted unsorted chunks")
        Add it to the head of unsorted bin
    else) // not top chunk
        Merge the chunk into a single top chunk
  
else)
    call munmap_chunk

Exception codes in Free

SIZE_SZ = sizeof(size_t)

  if (__builtin_expect (chunk_at_offset (p, size)->size <= 2 * SIZE_SZ, 0)
  || __builtin_expect (chunksize (chunk_at_offset (p, size))
               >= av->system_mem, 0))
    {
  /* We might not have a lock at this point and concurrent modifications
     of system_mem might have let to a false positive.  Redo the test
     after getting the lock.  */
  if (have_lock
      || ({ assert (locked == 0);
        mutex_lock(&av->mutex);
        locked = 1;
        chunk_at_offset (p, size)->size <= 2 * SIZE_SZ
          || chunksize (chunk_at_offset (p, size)) >= av->system_mem;
        }))
    {
      errstr = "free(): invalid next size (fast)";
      goto errout;
    }
  if (! have_lock)
    {
      (void)mutex_unlock(&av->mutex);
      locked = 0;
    }
    }
 
  free_perturb (chunk2mem(p), size - 2 * SIZE_SZ);
 
  set_fastchunks(av);
  unsigned int idx = fastbin_index(size);
  fb = &fastbin (av, idx);
 
  /* Atomically link P to its fastbin: P->FD = *FB; *FB = P;  */
  mchunkptr old = *fb, old2;
  unsigned int old_idx = ~0u;
  do
    {
  /* Check that the top of the bin is not the record we are going to add
     (i.e., double free).  */
  if (__builtin_expect (old == p, 0))
    {
      errstr = "double free or corruption (fasttop)";
      goto errout;
    }
  /* Check that size of fastbin chunk at the top is the same as
     size of the chunk that we are adding.  We can dereference OLD
     only if we have the lock, otherwise it might have already been
     deallocated.  See use of OLD_IDX below for the actual check.  */
  if (have_lock && old != NULL)
    old_idx = fastbin_index(chunksize(old));
  p->fd = old2 = old;
    }
  while ((old = catomic_compare_and_exchange_val_rel (fb, p, old2)) != old2);
 
  if (have_lock && old != NULL && __builtin_expect (old_idx != idx, 0))
    {
  errstr = "invalid fastbin entry (free)";
  goto errout;
    }
}
 
/*
  Consolidate other non-mmapped chunks as they arrive.
*/
 
else if (!chunk_is_mmapped(p)) {
  if (! have_lock) {
    (void)mutex_lock(&av->mutex);
    locked = 1;
  }
 
  nextchunk = chunk_at_offset(p, size);
 
  /* Lightweight tests: check whether the block is already the
     top block.  */
  if (__glibc_unlikely (p == av->top))
    {
  errstr = "double free or corruption (top)";
  goto errout;
    }
  /* Or whether the next chunk is beyond the boundaries of the arena.  */
  if (__builtin_expect (contiguous (av)
            && (char *) nextchunk
            >= ((char *) av->top + chunksize(av->top)), 0))
    {
  errstr = "double free or corruption (out)";
  goto errout;
    }
  /* Or whether the block is actually not marked used.  */
  if (__glibc_unlikely (!prev_inuse(nextchunk)))
    {
  errstr = "double free or corruption (!prev)";
  goto errout;
    }
 
  nextsize = chunksize(nextchunk);
  if (__builtin_expect (nextchunk->size <= 2 * SIZE_SZ, 0)
  || __builtin_expect (nextsize >= av->system_mem, 0))
    {
  errstr = "free(): invalid next size (normal)";
  goto errout;
    }
 
  free_perturb (chunk2mem(p), size - 2 * SIZE_SZ);
 
  /* consolidate backward */
  if (!prev_inuse(p)) {
    prevsize = p->prev_size;
    size += prevsize;
    p = chunk_at_offset(p, -((long) prevsize));
    unlink(av, p, bck, fwd);
  }
 
  if (nextchunk != av->top) {
    /* get and clear inuse bit */
    nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
 
    /* consolidate forward */
    if (!nextinuse) {
  unlink(av, nextchunk, bck, fwd);
  size += nextsize;
    } else
  clear_inuse_bit_at_offset(nextchunk, 0);
 
    /*
  Place the chunk in unsorted chunk list. Chunks are
  not placed into regular bins until after they have
  been given one chance to be used in malloc.
    */
 
    bck = unsorted_chunks(av);
    fwd = bck->fd;
    if (__glibc_unlikely (fwd->bk != bck))
  {
    errstr = "free(): corrupted unsorted chunks";
    goto errout;
  }

[Tool] Wordpress scanner - wpscan

dokydoky — Wed, 9 Aug 2017 15:45:01 +0900

WPScan is a black box WordPress vulnerability scanner

Repository : https://github.com/wpscanteam/wpscan

Install

Prerequisites

Ruby >= 2.1.9 - Recommended: 2.3.3
Curl >= 7.21 - Recommended: latest - FYI the 7.29 has a segfault
RubyGems - Recommended: latest
Git

Installing with RVM (recommended)

If you are using GNOME Terminal, there are some steps required before executing the commands. See here for more information: https://rvm.io/integration/gnome-terminal#integrating-rvm-with-gnome-terminal

# Install all prerequisites for your OS (look above)
cd ~
curl -sSL https://rvm.io/mpapis.asc | gpg --import -
curl -sSL https://get.rvm.io | bash -s stable
source ~/.rvm/scripts/rvm
echo "source ~/.rvm/scripts/rvm" >> ~/.bashrc
rvm install 2.3.3
rvm use 2.3.3 --default
echo "gem: --no-ri --no-rdoc" > ~/.gemrc
gem install bundler
git clone https://github.com/wpscanteam/wpscan.git
cd wpscan
gem install bundler
bundle install --without test

Usage

Update WPScan's databases...

ruby wpscan.rb --update

Do 'non-intrusive' checks...

ruby wpscan.rb --url www.example.com --random-agent

Run all enumeration tools...

ruby wpscan.rb --url www.example.com --enumerate --random-agent

Use custom content directory...

ref) we have to use "--random-agent" option because of Semantec

[C++] Smart pointer noncompliant code cases

dokydoky — Wed, 9 Aug 2017 15:41:52 +0900

팀내부에서 발표했던 자료중 Smart pointer관련 PPT.

[*NIX] Privilege Model

dokydoky — Wed, 9 Aug 2017 15:25:18 +0900

Introduction

SUID, GUID, 특정 Supplemental Group가 설정되어 있는 바이너리라면 Code audit할 때 최소한의 권한이 설정되어 있는지 잘 확인해야 한다.

권한 설정에 오류가 있으면 임의의 코드가 실행한 바이너리의 경우 쉽게 상위 권한을 얻을 수 있게 된다.

OS의 종류와 버전에 따라 그리고 root권한의 유무에 따라 API의 동작이 다르므로 주의해야 한다.

User ID

Types

Real user ID, Saved set-user-ID, Effective user ID

Functions

int setuid(uid_t uid);
 
int seteuid(uid_t euid);
  
int setreuid(uid_t ruid, uid_t euid);
  
int setresuid(uid_t ruid, uid_t euid, uid_t suid);

The sequence of fully drop User privileges

Superuser
- use setuid() // drop all of the user ID, Saved set-user-ID, Effective user ID

Nonsuperuser

//case 1. setresuid() : Linux, FreeBSD, HPUX, recent Open BSD
setresuid(getuid(), getuid(), getuid());
  
//case 2. setreuid() : For OS which doesn't support setresuid()
//        - Solaris, certain version of BSDs (OpenBSD before 3.3 doesn't support)
setreuid(getuid(), getuid());
  
//case 3. setuid() twice : OpenBSD before 3.3
setuid(getuid());
setuid(getuid());

Group ID

Types

Real group ID, Saved set-group-ID, Effective group ID, Supplemental Group IDs

Functions

int setgid(gid_t gid);
 
int setegid(gid_t egid);
  
int setregid(gid_t rgid, gid_t egid);
 
int setresgid(gid_t rgid, gid_t egid, gid_t sgid);
  
int setgroups(int ngroups, const gid_t *gidset); // effective user ID가 0일 때만 실행가능
  
int initgroups(const char *name, gid_t basegid); // effective user ID가 0일 때만 실행가능

The sequence of fully drop Group privileges

Superuser
// Dropping Supplemental Group Privileges
setgroups(0, NULL)

// Dropping Group Privileges
setgid(gid)

// Dropping User Privileges
setuid(uid)

Nonsuperuser

//case 1. setresgid()
setresgid(getgid(), getgid(), getgid());
  
//case 2. setregid() : For OS which doesn't support setresgid()
setregid(getgid(), getgid());
  
//case 3. setgid() twice : OpenBSD before 3.3
setgid(getgid());
setgid(getgid());

Audit Tips

Permanent dropping of privileges

Superuser
- effective user ID가 0인 상태로 실행되고 있는가?(setuid, setgid는 effective user ID가 0일 상태에서만 3가지 권한이 모두 변경된다.)
- supplemental group이 잠정적으로 안전하지 않다면 setgroups로 초기화해야 한다. 단, effective user ID가 0인 상태에서만 실행가능.
- real, saved set, effective 모두 다 변경되었는지 확인.(saved set의 변경에 주의)
- privileged group과 supplemental groups 초기화는 effective user ID가 변경되기 전에 수정되어야 한다.(권한문제)
Nonsuperuser
- setgroups()는 effective user ID가 0인 상태에서만 실행가능
- setuid(getuid()), setgid(getgid())를 사용할 때는 버전별로 API 실행이 다르므로 주의.

Temporary dropping of privileges

group permission, supplemental group permission 모두 설정되었는지 확인.
user permission보단 group permission을 먼저 설정해야 함.
권한을 drop하기 전에 올바르게 권한을 복구한 상태에서 실행하고있는가?(권한이 낮은 상태에서 실행하면 API 호출이 실패하거나 결과가 다를 수 있다.)
Effective user ID를 변경함으로써 signals, debugging API, special device file에 어떤 영향을 주는지 확인.

Reference.

The art of software security assessment. 7.5.3 Privilege Model

#dokydoky

Profile

HTTPS - 3. SSL/TLS History and Security

History & Security

SSL 2.0

SSL 3.0

TLS 1.0

TLS 1.1

TLS 1.2

TLS 1.2 vs 1.3

강화된 보안

향상된 속도

마치며

Reference

HTTPS - 2. HTTPS의 Ciphersuite, Handshake, Key derivation

들어가며

Cipher suites

Key establishment

RSA key exchange

Diffie-Hellman Key exchange

PFS(Perfect Forward secrecy)란?

ECC(Elliptic curves cryptography)란?

(Certificate) Authentication

Cipher

Data Integrity

Handshake

RSA handshake

Ephermeral Diffie-Hellman handshake

Key Derivation

PRF(PseudoRandom Function)

마치며

Reference

HTTPS - 1. 그림으로 살펴보는 HTTPS

들어가며

용어정리

Plaintext - HTTP

Symmetric encryption

RSA key exchange

Web PKI

마치며

Reference

[Heap Exploitation] Smallbin attack

Reference

smallbin

About smallbin

32bit

64bit

The code of getting chunk from smallbins in malloc

Attacks

House of Lore

공격개요

제약조건

[Heap Exploitation] Fastbin attack

Reference

Overview

Fastbin

32bit machine

64bit machine

Attacks

Double Free

공격개요

제약조건

Forging chunks

공격개요

제약조건

House of spirit

공격개요

제약조건

[Heap Exploitation] malloc & free(glibc 2.23)

Reference

Malloc

Malloc pseudo-code

Exception codes in Malloc

Free

Free pseudo-code

Exception codes in Free

[Tool] Wordpress scanner - wpscan

Install

Prerequisites

Installing with RVM (recommended)